@tablestore/tablestore-agent-cli 0.2.8 → 0.2.9

package/dist/dashboard-runtime/dashboard/src/components/retrieval/assemble-retrieval-configuration.ts

@@ -1,8 +1,12 @@
 import type { RetrievalInput } from "@/schemas/retrieval";
 import type { RetrievalRequest } from "@/types/retrieval";
 
-type RetrievalConfiguration = NonNullable<RetrievalRequest["retrievalConfiguration"]>;
-type RerankingConfiguration = NonNullable<RetrievalConfiguration["rerankingConfiguration"]>;
+type RetrievalConfiguration = NonNullable<
+  RetrievalRequest["retrievalConfiguration"]
+>;
+type RerankingConfiguration = NonNullable<
+  RetrievalConfiguration["rerankingConfiguration"]
+>;
 
 /**
  * Assemble the `retrievalConfiguration` slice of a retrieve request from the

package/dist/dashboard-runtime/dashboard/src/components/retrieval/filter-builder.tsx

@@ -1,6 +1,11 @@
 "use client";
 
-import React, { useRef, useReducer, useImperativeHandle, forwardRef } from "react";
+import React, {
+  useRef,
+  useReducer,
+  useImperativeHandle,
+  forwardRef,
+} from "react";
 import { Plus, X } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
@@ -11,6 +16,7 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
+import { useI18n } from "@/i18n/i18n-context";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -41,7 +47,7 @@ interface ConditionGroup {
 }
 
 function isConditionGroup(
-  item: ConditionRow | ConditionGroup
+  item: ConditionRow | ConditionGroup,
 ): item is ConditionGroup {
   return "logic" in item && "conditions" in item;
 }
@@ -51,12 +57,39 @@ function isConditionGroup(
 // ---------------------------------------------------------------------------
 
 const OPERATORS_BY_TYPE: Record<string, string[]> = {
-  string: ["equals", "notEquals", "in", "notIn", "startsWith", "stringContains"],
-  long: ["equals", "notEquals", "greaterThan", "greaterThanOrEquals", "lessThan", "lessThanOrEquals"],
-  double: ["equals", "notEquals", "greaterThan", "greaterThanOrEquals", "lessThan", "lessThanOrEquals"],
+  string: [
+    "equals",
+    "notEquals",
+    "in",
+    "notIn",
+    "startsWith",
+    "stringContains",
+  ],
+  long: [
+    "equals",
+    "notEquals",
+    "greaterThan",
+    "greaterThanOrEquals",
+    "lessThan",
+    "lessThanOrEquals",
+  ],
+  double: [
+    "equals",
+    "notEquals",
+    "greaterThan",
+    "greaterThanOrEquals",
+    "lessThan",
+    "lessThanOrEquals",
+  ],
   boolean: ["equals", "notEquals"],
   string_list: ["listContains", "in", "notIn"],
-  date: ["equals", "greaterThan", "greaterThanOrEquals", "lessThan", "lessThanOrEquals"],
+  date: [
+    "equals",
+    "greaterThan",
+    "greaterThanOrEquals",
+    "lessThan",
+    "lessThanOrEquals",
+  ],
 };
 
 function getOperatorsForType(fieldType: string): string[] {
@@ -74,15 +107,23 @@ function uid(): string {
 
 function resolveFieldType(
   fieldName: string,
-  fields: Array<{ name: string; type: string }>
+  fields: Array<{ name: string; type: string }>,
 ): string {
   return fields.find((f) => f.name === fieldName)?.type ?? "string";
 }
 
-function parseTypedValue(raw: string, fieldType: string, operator: string): unknown {
+function parseTypedValue(
+  raw: string,
+  fieldType: string,
+  operator: string,
+): unknown {
   if (operator === "in" || operator === "notIn") {
-    const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
-    if (fieldType === "long" || fieldType === "double") return parts.map(Number);
+    const parts = raw
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean);
+    if (fieldType === "long" || fieldType === "double")
+      return parts.map(Number);
     return parts;
   }
   if (fieldType === "long" || fieldType === "double") return Number(raw) || 0;
@@ -99,7 +140,7 @@ type Path = number[];
 function updateAtPath(
   group: ConditionGroup,
   path: Path,
-  updater: (parent: ConditionGroup) => ConditionGroup
+  updater: (parent: ConditionGroup) => ConditionGroup,
 ): ConditionGroup {
   if (path.length === 0) return updater(group);
   const [head, ...rest] = path;
@@ -117,7 +158,7 @@ function updateAtPath(
 
 function serializeGroup(
   group: ConditionGroup,
-  fields: Array<{ name: string; type: string }>
+  fields: Array<{ name: string; type: string }>,
 ): Record<string, unknown> | undefined {
   const items: Record<string, unknown>[] = [];
   for (const item of group.conditions) {
@@ -127,26 +168,44 @@ function serializeGroup(
     } else {
       if (!item.fieldName || !item.operator) continue;
       const ft = resolveFieldType(item.fieldName, fields);
-      items.push({ [item.operator]: { key: item.fieldName, value: parseTypedValue(item.value, ft, item.operator) } });
+      items.push({
+        [item.operator]: {
+          key: item.fieldName,
+          value: parseTypedValue(item.value, ft, item.operator),
+        },
+      });
     }
   }
   if (items.length === 0) return undefined;
   return { [group.logic]: items };
 }
 
-function deserializeFilter(filter: Record<string, unknown> | undefined): ConditionGroup {
+function deserializeFilter(
+  filter: Record<string, unknown> | undefined,
+): ConditionGroup {
   const def: ConditionGroup = { id: uid(), logic: "andAll", conditions: [] };
   if (!filter) return def;
-  const logicKey = Object.keys(filter).find((k) => ["andAll", "orAll", "notAll"].includes(k)) as LogicOperator | undefined;
+  const logicKey = Object.keys(filter).find((k) =>
+    ["andAll", "orAll", "notAll"].includes(k),
+  ) as LogicOperator | undefined;
   if (!logicKey || !Array.isArray(filter[logicKey])) return def;
   const items = filter[logicKey] as Record<string, unknown>[];
   const conditions: Array<ConditionRow | ConditionGroup> = items.map((item) => {
-    const nested = Object.keys(item).find((k) => ["andAll", "orAll", "notAll"].includes(k));
+    const nested = Object.keys(item).find((k) =>
+      ["andAll", "orAll", "notAll"].includes(k),
+    );
     if (nested) return deserializeFilter(item);
     const op = Object.keys(item)[0];
     const payload = item[op] as { key: string; value: unknown };
-    const rawValue = Array.isArray(payload.value) ? payload.value.join(", ") : String(payload.value ?? "");
-    return { id: uid(), fieldName: payload.key, operator: op, value: rawValue } as ConditionRow;
+    const rawValue = Array.isArray(payload.value)
+      ? payload.value.join(", ")
+      : String(payload.value ?? "");
+    return {
+      id: uid(),
+      fieldName: payload.key,
+      operator: op,
+      value: rawValue,
+    } as ConditionRow;
   });
   return { id: uid(), logic: logicKey, conditions };
 }
@@ -165,7 +224,10 @@ type Action =
 function reducer(state: ConditionGroup, action: Action): ConditionGroup {
   switch (action.type) {
     case "SET_LOGIC":
-      return updateAtPath(state, action.path, (g) => ({ ...g, logic: action.logic }));
+      return updateAtPath(state, action.path, (g) => ({
+        ...g,
+        logic: action.logic,
+      }));
     case "UPDATE_ROW":
       return updateAtPath(state, action.path, (g) => {
         const c = [...g.conditions];
@@ -207,29 +269,67 @@ function ConditionRowEditor({
   onUpdate: (updated: ConditionRow) => void;
   onRemove: () => void;
 }) {
+  const { t } = useI18n();
   const fieldType = resolveFieldType(condition.fieldName, metadataFields);
   const operators = getOperatorsForType(fieldType);
-  const isArrayOp = condition.operator === "in" || condition.operator === "notIn";
+  const isArrayOp =
+    condition.operator === "in" || condition.operator === "notIn";
 
   return (
     <div className="flex items-center gap-1.5 min-w-0">
-      <Select value={condition.fieldName} onValueChange={(v) => {
-        const newType = resolveFieldType(v, metadataFields);
-        const newOps = getOperatorsForType(newType);
-        onUpdate({ ...condition, fieldName: v, operator: newOps.includes(condition.operator) ? condition.operator : newOps[0], value: "" });
-      }}>
-        <SelectTrigger className="min-w-0 flex-1"><SelectValue placeholder="选择字段" /></SelectTrigger>
-        <SelectContent>{metadataFields.map((f) => <SelectItem key={f.name} value={f.name}>{f.name} ({f.type})</SelectItem>)}</SelectContent>
+      <Select
+        value={condition.fieldName}
+        onValueChange={(v) => {
+          const newType = resolveFieldType(v, metadataFields);
+          const newOps = getOperatorsForType(newType);
+          onUpdate({
+            ...condition,
+            fieldName: v,
+            operator: newOps.includes(condition.operator)
+              ? condition.operator
+              : newOps[0],
+            value: "",
+          });
+        }}
+      >
+        <SelectTrigger className="min-w-0 flex-1">
+          <SelectValue placeholder={t("retrieval.filter.selectField")} />
+        </SelectTrigger>
+        <SelectContent>
+          {metadataFields.map((f) => (
+            <SelectItem key={f.name} value={f.name}>
+              {f.name} ({f.type})
+            </SelectItem>
+          ))}
+        </SelectContent>
       </Select>
 
-      <Select value={condition.operator} onValueChange={(v) => onUpdate({ ...condition, operator: v, value: "" })}>
-        <SelectTrigger className="min-w-0 flex-1"><SelectValue placeholder="操作符" /></SelectTrigger>
-        <SelectContent>{operators.map((op) => <SelectItem key={op} value={op}>{op}</SelectItem>)}</SelectContent>
+      <Select
+        value={condition.operator}
+        onValueChange={(v) =>
+          onUpdate({ ...condition, operator: v, value: "" })
+        }
+      >
+        <SelectTrigger className="min-w-0 flex-1">
+          <SelectValue placeholder={t("retrieval.filter.operator")} />
+        </SelectTrigger>
+        <SelectContent>
+          {operators.map((op) => (
+            <SelectItem key={op} value={op}>
+              {op}
+            </SelectItem>
+          ))}
+        </SelectContent>
       </Select>
 
       {fieldType === "boolean" ? (
-        <Select value={condition.value} onValueChange={(v) => onUpdate({ ...condition, value: v })}>
-          <SelectTrigger className="min-w-0 flex-1"><SelectValue placeholder="选择值" /></SelectTrigger>
+        <Select
+          value={condition.value}
+          onValueChange={(v) => onUpdate({ ...condition, value: v })}
+        >
+          <SelectTrigger className="min-w-0 flex-1">
+            <SelectValue placeholder={t("retrieval.filter.selectValue")} />
+          </SelectTrigger>
           <SelectContent>
             <SelectItem value="true">true</SelectItem>
             <SelectItem value="false">false</SelectItem>
@@ -238,14 +338,26 @@ function ConditionRowEditor({
       ) : (
         <Input
           className="min-w-0 flex-1"
-          type={fieldType === "long" || fieldType === "double" ? "number" : "text"}
-          placeholder={isArrayOp ? "值1, 值2, 值3" : "输入值"}
+          type={
+            fieldType === "long" || fieldType === "double" ? "number" : "text"
+          }
+          placeholder={
+            isArrayOp
+              ? t("retrieval.filter.valueListPlaceholder")
+              : t("retrieval.filter.valuePlaceholder")
+          }
           value={condition.value}
           onChange={(e) => onUpdate({ ...condition, value: e.target.value })}
         />
       )}
 
-      <Button type="button" variant="ghost" size="icon" className="h-7 w-7 shrink-0 text-[hsl(var(--muted-foreground))] hover:text-[hsl(var(--destructive))]" onClick={onRemove}>
+      <Button
+        type="button"
+        variant="ghost"
+        size="icon"
+        className="h-7 w-7 shrink-0 text-[hsl(var(--muted-foreground))] hover:text-[hsl(var(--destructive))]"
+        onClick={onRemove}
+      >
         <X className="h-3.5 w-3.5" />
       </Button>
     </div>
@@ -271,24 +383,46 @@ function GroupEditor({
   dispatch: React.Dispatch<Action>;
   onRemoveSelf?: () => void;
 }) {
+  const { t } = useI18n();
   const canNest = depth < 1;
   const defaultField = metadataFields[0];
-  const defaultOp = defaultField ? getOperatorsForType(defaultField.type)[0] : "equals";
+  const defaultOp = defaultField
+    ? getOperatorsForType(defaultField.type)[0]
+    : "equals";
 
   return (
-    <div className={`rounded-md border border-[hsl(var(--border))] p-3 ${depth > 0 ? "bg-[hsl(var(--muted))]/30" : ""}`}>
+    <div
+      className={`rounded-md border border-[hsl(var(--border))] p-3 ${depth > 0 ? "bg-[hsl(var(--muted))]/30" : ""}`}
+    >
       {/* Header: logic selector + remove */}
       <div className="flex items-center gap-2 mb-3">
-        <Select value={group.logic} onValueChange={(v) => dispatch({ type: "SET_LOGIC", path, logic: v as LogicOperator })}>
-          <SelectTrigger className="w-[120px] h-8 text-xs font-medium"><SelectValue /></SelectTrigger>
+        <Select
+          value={group.logic}
+          onValueChange={(v) =>
+            dispatch({ type: "SET_LOGIC", path, logic: v as LogicOperator })
+          }
+        >
+          <SelectTrigger className="w-[120px] h-8 text-xs font-medium">
+            <SelectValue />
+          </SelectTrigger>
           <SelectContent>
-            <SelectItem value="andAll">AND (全部满足)</SelectItem>
-            <SelectItem value="orAll">OR (任一满足)</SelectItem>
-            <SelectItem value="notAll">NOT (全不满足)</SelectItem>
+            <SelectItem value="andAll">
+              {t("retrieval.filter.andAll")}
+            </SelectItem>
+            <SelectItem value="orAll">{t("retrieval.filter.orAll")}</SelectItem>
+            <SelectItem value="notAll">
+              {t("retrieval.filter.notAll")}
+            </SelectItem>
           </SelectContent>
         </Select>
         {onRemoveSelf && (
-          <Button type="button" variant="ghost" size="icon" className="h-7 w-7 shrink-0 text-[hsl(var(--muted-foreground))] hover:text-[hsl(var(--destructive))]" onClick={onRemoveSelf}>
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon"
+            className="h-7 w-7 shrink-0 text-[hsl(var(--muted-foreground))] hover:text-[hsl(var(--destructive))]"
+            onClick={onRemoveSelf}
+          >
             <X className="h-3.5 w-3.5" />
           </Button>
         )}
@@ -305,32 +439,63 @@ function GroupEditor({
               path={[...path, idx]}
               depth={depth + 1}
               dispatch={dispatch}
-              onRemoveSelf={() => dispatch({ type: "REMOVE_AT", path, index: idx })}
+              onRemoveSelf={() =>
+                dispatch({ type: "REMOVE_AT", path, index: idx })
+              }
             />
           ) : (
             <ConditionRowEditor
               key={item.id}
               condition={item}
               metadataFields={metadataFields}
-              onUpdate={(updated) => dispatch({ type: "UPDATE_ROW", path, index: idx, row: updated })}
+              onUpdate={(updated) =>
+                dispatch({ type: "UPDATE_ROW", path, index: idx, row: updated })
+              }
               onRemove={() => dispatch({ type: "REMOVE_AT", path, index: idx })}
             />
-          )
+          ),
         )}
       </div>
 
       {/* Actions */}
       <div className="flex items-center gap-2 mt-3 pt-2 border-t border-[hsl(var(--border))]/50">
-        <Button type="button" variant="ghost" size="sm" className="h-7 text-xs" onClick={() =>
-          dispatch({ type: "ADD_ROW", path, row: { id: uid(), fieldName: defaultField?.name ?? "", operator: defaultOp, value: "" } })
-        }>
-          <Plus className="h-3.5 w-3.5 mr-1" />添加条件
+        <Button
+          type="button"
+          variant="ghost"
+          size="sm"
+          className="h-7 text-xs"
+          onClick={() =>
+            dispatch({
+              type: "ADD_ROW",
+              path,
+              row: {
+                id: uid(),
+                fieldName: defaultField?.name ?? "",
+                operator: defaultOp,
+                value: "",
+              },
+            })
+          }
+        >
+          <Plus className="h-3.5 w-3.5 mr-1" />
+          {t("retrieval.filter.addCondition")}
         </Button>
         {canNest && (
-          <Button type="button" variant="ghost" size="sm" className="h-7 text-xs" onClick={() =>
-            dispatch({ type: "ADD_GROUP", path, group: { id: uid(), logic: "orAll", conditions: [] } })
-          }>
-            <Plus className="h-3.5 w-3.5 mr-1" />添加条件组
+          <Button
+            type="button"
+            variant="ghost"
+            size="sm"
+            className="h-7 text-xs"
+            onClick={() =>
+              dispatch({
+                type: "ADD_GROUP",
+                path,
+                group: { id: uid(), logic: "orAll", conditions: [] },
+              })
+            }
+          >
+            <Plus className="h-3.5 w-3.5 mr-1" />
+            {t("retrieval.filter.addGroup")}
           </Button>
         )}
       </div>
@@ -342,43 +507,51 @@ function GroupEditor({
 // FilterBuilder (main export) — uses ref instead of onChange to avoid re-renders
 // ---------------------------------------------------------------------------
 
-export const FilterBuilder = forwardRef<FilterBuilderHandle, FilterBuilderProps>(
-  function FilterBuilder({ metadataFields, initialValue }, ref) {
-    const [rootGroup, dispatch] = useReducer(reducer, initialValue, deserializeFilter);
-
-    // Expose getFilter via ref — parent reads filter on submit, no re-render loop
-    const fieldsRef = useRef(metadataFields);
-    fieldsRef.current = metadataFields;
+export const FilterBuilder = forwardRef<
+  FilterBuilderHandle,
+  FilterBuilderProps
+>(function FilterBuilder({ metadataFields, initialValue }, ref) {
+  const { t } = useI18n();
+  const [rootGroup, dispatch] = useReducer(
+    reducer,
+    initialValue,
+    deserializeFilter,
+  );
 
-    // Design decision: We use useImperativeHandle + ref to expose getFilter()
-    // instead of an onChange callback pattern. This avoids a re-render loop where
-    // filter changes → parent re-renders → FilterBuilder re-renders → dispatches
-    // again. The parent reads the filter value imperatively on form submit, which
-    // keeps the FilterBuilder fully uncontrolled and avoids unnecessary renders.
-    useImperativeHandle(ref, () => ({
+  // Expose getFilter via ref — parent reads filter on submit, no re-render loop
+  const fieldsRef = useRef(metadataFields);
+  fieldsRef.current = metadataFields;
+
+  // Design decision: We use useImperativeHandle + ref to expose getFilter()
+  // instead of an onChange callback pattern. This avoids a re-render loop where
+  // filter changes → parent re-renders → FilterBuilder re-renders → dispatches
+  // again. The parent reads the filter value imperatively on form submit, which
+  // keeps the FilterBuilder fully uncontrolled and avoids unnecessary renders.
+  useImperativeHandle(
+    ref,
+    () => ({
       getFilter: () => serializeGroup(rootGroup, fieldsRef.current),
-    }), [rootGroup]);
-
-    if (metadataFields.length === 0) {
-      return (
-        <div className="rounded-md border border-[hsl(var(--border))] p-4 text-sm text-[hsl(var(--muted-foreground))]">
-          该知识库未定义 Metadata Schema，无法使用过滤器
-        </div>
-      );
-    }
+    }),
+    [rootGroup],
+  );
 
+  if (metadataFields.length === 0) {
     return (
-      <div className="space-y-3">
-        <GroupEditor
-          group={rootGroup}
-          metadataFields={metadataFields}
-          path={[]}
-          depth={0}
-          dispatch={dispatch}
-        />
-
-
+      <div className="rounded-md border border-[hsl(var(--border))] p-4 text-sm text-[hsl(var(--muted-foreground))]">
+        {t("retrieval.filter.noSchema")}
       </div>
     );
   }
-);
+
+  return (
+    <div className="space-y-3">
+      <GroupEditor
+        group={rootGroup}
+        metadataFields={metadataFields}
+        path={[]}
+        depth={0}
+        dispatch={dispatch}
+      />
+    </div>
+  );
+});

package/dist/dashboard-runtime/dashboard/src/components/retrieval/request-preview.tsx

@@ -1,19 +1,23 @@
-'use client';
+"use client";
 
 import { useState } from "react";
 import { Braces, Copy, Check, X } from "lucide-react";
 import { Button } from "@/components/ui/button";
+import { useI18n } from "@/i18n/i18n-context";
 
 interface RequestPreviewProps {
   buildRequestJson: () => Record<string, unknown>;
 }
 
 export function RequestPreview({ buildRequestJson }: RequestPreviewProps) {
+  const { t } = useI18n();
   const [isOpen, setIsOpen] = useState(false);
   const [isCopied, setIsCopied] = useState(false);
 
   // Compute JSON only when panel is open — reads latest filter from ref
-  const formattedJson = isOpen ? JSON.stringify(buildRequestJson(), null, 2) : "";
+  const formattedJson = isOpen
+    ? JSON.stringify(buildRequestJson(), null, 2)
+    : "";
 
   async function handleCopy() {
     try {
@@ -35,7 +39,7 @@ export function RequestPreview({ buildRequestJson }: RequestPreviewProps) {
         className="gap-1.5 text-[hsl(var(--muted-foreground))]"
       >
         <Braces className="h-4 w-4" />
-        请求预览
+        {t("retrieval.preview.title")}
       </Button>
 
       {isOpen && (
@@ -43,7 +47,9 @@ export function RequestPreview({ buildRequestJson }: RequestPreviewProps) {
           <div className="relative rounded-lg border border-[hsl(var(--border))] bg-[hsl(var(--background))] shadow-lg">
             <div className="absolute right-2 top-2 flex items-center gap-1">
               {isCopied && (
-                <span className="text-xs text-green-500">已复制</span>
+                <span className="text-xs text-green-500">
+                  {t("retrieval.preview.copied")}
+                </span>
               )}
               <Button
                 type="button"