@tablestore/tablestore-agent-cli 0.3.1 → 0.4.1

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

@@ -0,0 +1,393 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import { Plus, Trash2 } 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 {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { useI18n } from "@/i18n/i18n-context";
+import type {
+  ScopeDirectoryFilter,
+  ScopeDirectoryLeafFilter,
+} from "@/types/memory";
+
+export type ScopeFilterCombinator = "and" | "or";
+export type ScopeFilterOperator =
+  "eq" | "in" | "prefix" | "wildcard" | "range" | "exists";
+
+export interface ScopeFilterRule {
+  id: string;
+  field: string;
+  operator: ScopeFilterOperator;
+  value: string;
+  endValue: string;
+  negate: boolean;
+}
+
+const FILTER_FIELDS = [
+  "scopeType",
+  "appId",
+  "tenantId",
+  "agentId",
+  "runId",
+  "wikiId",
+  "scopeKey",
+] as const;
+
+const FILTER_OPERATORS: ScopeFilterOperator[] = [
+  "eq",
+  "in",
+  "prefix",
+  "wildcard",
+  "range",
+  "exists",
+];
+
+interface VisualScopeFilterState {
+  combinator: ScopeFilterCombinator;
+  rules: ScopeFilterRule[];
+  filter: ScopeDirectoryFilter;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function restoredRule(value: unknown, index: number): ScopeFilterRule | null {
+  let negate = false;
+  let leaf = value;
+  if (isRecord(value) && value.op === "not") {
+    negate = true;
+    leaf = value.condition;
+  }
+  if (!isRecord(leaf) || typeof leaf.op !== "string") return null;
+  if (
+    typeof leaf.field !== "string" ||
+    !(FILTER_FIELDS as readonly string[]).includes(leaf.field)
+  ) {
+    return null;
+  }
+
+  const base = newRule(`scope-filter-${index + 1}`);
+  base.field = leaf.field;
+  base.negate = negate;
+  if (
+    (leaf.op === "eq" || leaf.op === "prefix" || leaf.op === "wildcard") &&
+    typeof leaf.value === "string"
+  ) {
+    return { ...base, operator: leaf.op, value: leaf.value };
+  }
+  if (
+    leaf.op === "in" &&
+    Array.isArray(leaf.values) &&
+    leaf.values.length > 0 &&
+    leaf.values.every((item) => typeof item === "string")
+  ) {
+    return { ...base, operator: "in", value: leaf.values.join(", ") };
+  }
+  if (
+    leaf.op === "range" &&
+    (typeof leaf.gte === "string" || typeof leaf.lte === "string") &&
+    leaf.gt === undefined &&
+    leaf.lt === undefined
+  ) {
+    return {
+      ...base,
+      operator: "range",
+      value: typeof leaf.gte === "string" ? leaf.gte : "",
+      endValue: typeof leaf.lte === "string" ? leaf.lte : "",
+    };
+  }
+  if (leaf.op === "exists") {
+    return { ...base, operator: "exists" };
+  }
+  return null;
+}
+
+/** Restore only Filter shapes the visual builder itself can produce. Invalid
+ * or more deeply nested URL state is ignored instead of being submitted as an
+ * invisible constraint. */
+export function restoreVisualScopeFilter(
+  value: unknown,
+): VisualScopeFilterState | undefined {
+  const root = isRecord(value) ? value : null;
+  if (!root || typeof root.op !== "string") return undefined;
+  const combinator: ScopeFilterCombinator = root.op === "or" ? "or" : "and";
+  const conditions =
+    root.op === "and" || root.op === "or"
+      ? Array.isArray(root.conditions)
+        ? root.conditions
+        : []
+      : [value];
+  if (conditions.length === 0 || conditions.length > 64) return undefined;
+
+  const rules = conditions.map(restoredRule);
+  if (rules.some((rule) => rule === null)) return undefined;
+  const restoredRules = rules as ScopeFilterRule[];
+  const filter = buildVisualScopeFilter(restoredRules, combinator);
+  return filter ? { combinator, rules: restoredRules, filter } : undefined;
+}
+
+export function parseSerializedVisualScopeFilter(
+  value: string | null,
+): VisualScopeFilterState | undefined {
+  if (!value) return undefined;
+  try {
+    return restoreVisualScopeFilter(JSON.parse(value) as unknown);
+  } catch {
+    return undefined;
+  }
+}
+
+function buildLeaf(rule: ScopeFilterRule): ScopeDirectoryLeafFilter | null {
+  const field = rule.field.trim();
+  if (!field) return null;
+  if (rule.operator === "exists") return { op: "exists", field };
+
+  const value = rule.value.trim();
+  if (rule.operator === "in") {
+    const values = [
+      ...new Set(value.split(",").map((item) => item.trim())),
+    ].filter(Boolean);
+    return values.length > 0 ? { op: "in", field, values } : null;
+  }
+  if (rule.operator === "range") {
+    const endValue = rule.endValue.trim();
+    if (!value && !endValue) return null;
+    return {
+      op: "range",
+      field,
+      ...(value ? { gte: value } : {}),
+      ...(endValue ? { lte: endValue } : {}),
+    };
+  }
+  if (!value) return null;
+  return { op: rule.operator, field, value };
+}
+
+/** Convert the visual rule group into the server Filter AST. Blank rows are
+ * intentionally ignored so adding a row never changes a request until the
+ * user has selected a meaningful value. */
+export function buildVisualScopeFilter(
+  rules: ScopeFilterRule[],
+  combinator: ScopeFilterCombinator,
+): ScopeDirectoryFilter | undefined {
+  const conditions = rules.flatMap<ScopeDirectoryFilter>((rule) => {
+    const leaf = buildLeaf(rule);
+    if (!leaf) return [];
+    return [rule.negate ? { op: "not", condition: leaf } : leaf];
+  });
+  if (conditions.length === 0) return undefined;
+  if (conditions.length === 1) return conditions[0];
+  return { op: combinator, conditions };
+}
+
+function newRule(id: string): ScopeFilterRule {
+  return {
+    id,
+    field: "appId",
+    operator: "eq",
+    value: "",
+    endValue: "",
+    negate: false,
+  };
+}
+
+export function ScopeFilterBuilder({
+  initialFilter,
+  onChange,
+}: {
+  initialFilter?: ScopeDirectoryFilter;
+  onChange: (filter: ScopeDirectoryFilter | undefined) => void;
+}) {
+  const { t } = useI18n();
+  const [initialState] = useState(() =>
+    restoreVisualScopeFilter(initialFilter),
+  );
+  const nextId = useRef((initialState?.rules.length ?? 0) + 1);
+  const onChangeRef = useRef(onChange);
+  const [combinator, setCombinator] = useState<ScopeFilterCombinator>(
+    initialState?.combinator ?? "and",
+  );
+  const [rules, setRules] = useState<ScopeFilterRule[]>(
+    initialState?.rules ?? [],
+  );
+
+  useEffect(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+
+  useEffect(() => {
+    onChangeRef.current(buildVisualScopeFilter(rules, combinator));
+  }, [combinator, rules]);
+
+  function updateRule(id: string, patch: Partial<ScopeFilterRule>) {
+    setRules((current) =>
+      current.map((rule) => (rule.id === id ? { ...rule, ...patch } : rule)),
+    );
+  }
+
+  function addRule() {
+    const id = `scope-filter-${nextId.current}`;
+    nextId.current += 1;
+    setRules((current) => [...current, newRule(id)]);
+  }
+
+  function removeRule(id: string) {
+    setRules((current) => current.filter((rule) => rule.id !== id));
+  }
+
+  return (
+    <section
+      className="space-y-3 rounded-lg border border-[hsl(var(--border))] bg-[hsl(var(--muted)/0.2)] p-3"
+      data-testid="scope-filter-builder"
+    >
+      <div className="flex flex-wrap items-center justify-between gap-2">
+        <div>
+          <Label>{t("memory.search.scopeFilter")}</Label>
+          <p className="mt-1 text-xs text-muted-foreground">
+            {t("memory.search.scopeFilterHelp")}
+          </p>
+        </div>
+        {rules.length > 1 ? (
+          <Select
+            value={combinator}
+            onValueChange={(value) =>
+              setCombinator(value as ScopeFilterCombinator)
+            }
+          >
+            <SelectTrigger className="h-8 w-[132px]">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="and">
+                {t("memory.search.scopeFilterMatchAll")}
+              </SelectItem>
+              <SelectItem value="or">
+                {t("memory.search.scopeFilterMatchAny")}
+              </SelectItem>
+            </SelectContent>
+          </Select>
+        ) : null}
+      </div>
+
+      <div className="space-y-2">
+        {rules.map((rule, index) => (
+          <div
+            key={rule.id}
+            className="space-y-2 rounded-md border bg-background p-2.5"
+          >
+            <div className="flex items-center justify-between gap-2">
+              <span className="text-xs font-medium text-muted-foreground">
+                {t("memory.search.scopeFilterCondition", { index: index + 1 })}
+              </span>
+              <Button
+                type="button"
+                variant="ghost"
+                size="icon"
+                className="h-7 w-7"
+                aria-label={t("memory.search.scopeFilterRemove")}
+                onClick={() => removeRule(rule.id)}
+              >
+                <Trash2 className="h-3.5 w-3.5" />
+              </Button>
+            </div>
+            <div className="grid gap-2">
+              <Select
+                value={rule.field}
+                onValueChange={(field) => updateRule(rule.id, { field })}
+              >
+                <SelectTrigger aria-label={t("memory.search.scopeFilterField")}>
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {FILTER_FIELDS.map((field) => (
+                    <SelectItem key={field} value={field}>
+                      {t(`memory.search.scopeFilterField_${field}`)}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+              <Select
+                value={rule.operator}
+                onValueChange={(operator) =>
+                  updateRule(rule.id, {
+                    operator: operator as ScopeFilterOperator,
+                  })
+                }
+              >
+                <SelectTrigger
+                  aria-label={t("memory.search.scopeFilterOperator")}
+                >
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {FILTER_OPERATORS.map((operator) => (
+                    <SelectItem key={operator} value={operator}>
+                      {t(`memory.search.scopeFilterOperator_${operator}`)}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+
+            {rule.operator === "range" ? (
+              <div className="grid grid-cols-2 gap-2">
+                <Input
+                  value={rule.value}
+                  onChange={(event) =>
+                    updateRule(rule.id, { value: event.target.value })
+                  }
+                  placeholder={t("memory.search.scopeFilterRangeStart")}
+                />
+                <Input
+                  value={rule.endValue}
+                  onChange={(event) =>
+                    updateRule(rule.id, { endValue: event.target.value })
+                  }
+                  placeholder={t("memory.search.scopeFilterRangeEnd")}
+                />
+              </div>
+            ) : rule.operator !== "exists" ? (
+              <Input
+                value={rule.value}
+                onChange={(event) =>
+                  updateRule(rule.id, { value: event.target.value })
+                }
+                placeholder={
+                  rule.operator === "in"
+                    ? t("memory.search.scopeFilterValuesPlaceholder")
+                    : t("memory.search.scopeFilterValuePlaceholder")
+                }
+              />
+            ) : null}
+
+            <label className="flex items-center gap-2 text-xs text-muted-foreground">
+              <Checkbox
+                checked={rule.negate}
+                onCheckedChange={(checked) =>
+                  updateRule(rule.id, { negate: checked === true })
+                }
+              />
+              {t("memory.search.scopeFilterNegate")}
+            </label>
+          </div>
+        ))}
+      </div>
+
+      <Button type="button" variant="outline" size="sm" onClick={addRule}>
+        <Plus className="h-3.5 w-3.5" />
+        {t("memory.search.scopeFilterAdd")}
+      </Button>
+    </section>
+  );
+}

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

@@ -0,0 +1,274 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+
+import { Button } from "@/components/ui/button";
+import type { MessageKey, TranslateFn } from "@/i18n/i18n-context";
+import { scopeLabel } from "@/lib/memory";
+import {
+  filterScopeTuples,
+  normalizeHierarchicalScope,
+  scopeAtLevel,
+  scopeBreadcrumb,
+  scopeChildren,
+  scopeGranularity,
+  scopeWithSelection,
+  SCOPE_LEVELS,
+  SCOPE_FIELD_BY_LEVEL,
+  type ScopeGranularity,
+  type ScopeLevel,
+} from "@/lib/scope-hierarchy";
+import type { MemoryScope } from "@/types/memory";
+import { cn } from "@/lib/utils";
+
+export interface ScopeHierarchyPickerProps {
+  scopes: readonly MemoryScope[];
+  currentScope: MemoryScope;
+  search: string;
+  onSearchChange: (value: string) => void;
+  onApply: (scope: MemoryScope) => void;
+  loading?: boolean;
+  error?: boolean;
+  truncated?: boolean;
+  onRetry?: () => void;
+  allowPartial?: boolean;
+  optionLimit?: number;
+  maxLevel?: ScopeLevel;
+  t: TranslateFn;
+}
+
+const ALL_SCOPE: MemoryScope = {
+  appId: "*",
+  tenantId: "*",
+  agentId: "*",
+  runId: "*",
+};
+
+const CHOOSE_KEY: Record<ScopeLevel, MessageKey> = {
+  app: "memory.scopeHierarchy.chooseApp",
+  tenant: "memory.scopeHierarchy.chooseTenant",
+  agent: "memory.scopeHierarchy.chooseAgent",
+  run: "memory.scopeHierarchy.chooseRun",
+};
+
+const ALL_CHILDREN_KEY: Record<ScopeLevel, MessageKey> = {
+  app: "memory.scopeHierarchy.allApps",
+  tenant: "memory.scopeHierarchy.allTenants",
+  agent: "memory.scopeHierarchy.allAgents",
+  run: "memory.scopeHierarchy.allRuns",
+};
+
+const RANGE_KEY: Record<ScopeGranularity, MessageKey> = {
+  all: "memory.scopeHierarchy.allRange",
+  app: "memory.scopeHierarchy.appRange",
+  tenant: "memory.scopeHierarchy.tenantRange",
+  agent: "memory.scopeHierarchy.agentRange",
+  run: "memory.scopeHierarchy.runRange",
+};
+
+function identity(scope: MemoryScope): string {
+  return JSON.stringify([
+    scope.appId,
+    scope.tenantId,
+    scope.agentId,
+    scope.runId,
+  ]);
+}
+
+export function ScopeHierarchyPicker({
+  scopes,
+  currentScope,
+  search,
+  onApply,
+  loading = false,
+  error = false,
+  truncated = false,
+  onRetry,
+  allowPartial = false,
+  optionLimit,
+  maxLevel = "run",
+  t,
+}: ScopeHierarchyPickerProps) {
+  const normalizedCurrent =
+    normalizeHierarchicalScope(currentScope) ?? ALL_SCOPE;
+  const [draft, setDraft] = useState<MemoryScope>(normalizedCurrent);
+
+  useEffect(() => {
+    setDraft(normalizeHierarchicalScope(currentScope) ?? ALL_SCOPE);
+  }, [currentScope]);
+
+  const granularity = scopeGranularity(draft);
+  const breadcrumb = scopeBreadcrumb(draft);
+  const children = useMemo(() => {
+    if (
+      granularity !== "all" &&
+      SCOPE_LEVELS.indexOf(granularity) >= SCOPE_LEVELS.indexOf(maxLevel)
+    ) {
+      return [];
+    }
+    const items = scopeChildren(scopes, draft);
+    return optionLimit === undefined ? items : items.slice(0, optionLimit);
+  }, [draft, granularity, maxLevel, optionLimit, scopes]);
+  const searchResults = useMemo(() => {
+    const seen = new Set<string>();
+    const matches = filterScopeTuples(scopes, search).filter((scope) => {
+      const key = identity(scope);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    const limited =
+      optionLimit === undefined ? matches : matches.slice(0, optionLimit);
+    return limited.map((scope) => scopeAtLevel(scope, maxLevel));
+  }, [maxLevel, optionLimit, scopes, search]);
+  const isSearching = search.trim().length > 0;
+
+  function selectLevel(level: ScopeLevel) {
+    setDraft(scopeAtLevel(draft, level));
+  }
+
+  function selectChild(level: ScopeLevel, value: string) {
+    const next = scopeWithSelection(draft, SCOPE_FIELD_BY_LEVEL[level], value);
+    setDraft(next);
+    if (level === maxLevel) onApply(next);
+  }
+
+  return (
+    <div className="space-y-2 p-2">
+      <nav
+        aria-label={t("memory.scopeHierarchy.breadcrumb")}
+        className="flex min-w-0 items-center gap-1 overflow-x-auto text-xs"
+      >
+        <button
+          type="button"
+          aria-current={granularity === "all" ? "step" : undefined}
+          onClick={() => setDraft({ ...ALL_SCOPE })}
+          className="shrink-0 rounded px-1.5 py-1 text-muted-foreground hover:bg-[hsl(var(--accent))]"
+        >
+          {t("memory.common.allData")}
+        </button>
+        {breadcrumb.map((item) => (
+          <span key={item.level} className="flex min-w-0 items-center gap-1">
+            <span aria-hidden="true" className="text-muted-foreground">
+              /
+            </span>
+            <button
+              type="button"
+              aria-current={item.level === granularity ? "step" : undefined}
+              onClick={() => selectLevel(item.level)}
+              disabled={!item.concrete}
+              className={cn(
+                "max-w-32 truncate rounded px-1.5 py-1",
+                item.concrete
+                  ? "font-mono hover:bg-[hsl(var(--accent))]"
+                  : "cursor-default text-muted-foreground",
+              )}
+              title={
+                item.concrete ? item.value : t(ALL_CHILDREN_KEY[item.level])
+              }
+            >
+              {item.concrete ? item.value : t(ALL_CHILDREN_KEY[item.level])}
+            </button>
+          </span>
+        ))}
+      </nav>
+
+      {loading ? (
+        <p className="px-2 py-3 text-xs text-muted-foreground">
+          {t("common.loading")}
+        </p>
+      ) : error ? (
+        <div className="flex items-center justify-between gap-2 px-2 py-3 text-xs text-muted-foreground">
+          <span>{t("memory.scopeCombobox.loadFailed")}</span>
+          {onRetry ? (
+            <Button type="button" size="sm" variant="ghost" onClick={onRetry}>
+              {t("common.refresh")}
+            </Button>
+          ) : null}
+        </div>
+      ) : isSearching ? (
+        <div className="space-y-1" role="listbox">
+          {searchResults.length > 0 ? (
+            searchResults.map((scope) => {
+              const normalized = normalizeHierarchicalScope(scope);
+              if (!normalized) return null;
+              const label = scopeLabel(normalized);
+              return (
+                <button
+                  key={identity(normalized)}
+                  type="button"
+                  role="option"
+                  aria-label={label}
+                  aria-selected={
+                    identity(normalized) ===
+                    identity(scopeAtLevel(draft, maxLevel))
+                  }
+                  onClick={() => onApply(normalized)}
+                  className="block w-full truncate rounded px-2 py-1.5 text-left font-mono text-xs hover:bg-[hsl(var(--accent))]"
+                >
+                  {label}
+                </button>
+              );
+            })
+          ) : (
+            <p className="px-2 py-3 text-xs text-muted-foreground">
+              {t("memory.common.noMatchingScope")}
+            </p>
+          )}
+        </div>
+      ) : (
+        <div className="space-y-1" role="listbox">
+          {children.length > 0 ? (
+            children.map((child) => (
+              <button
+                key={`${child.level}:${child.value}`}
+                type="button"
+                role="option"
+                aria-label={t(CHOOSE_KEY[child.level], { value: child.value })}
+                aria-selected={
+                  draft[SCOPE_FIELD_BY_LEVEL[child.level]] === child.value
+                }
+                onClick={() => selectChild(child.level, child.value)}
+                className="block w-full truncate rounded px-2 py-1.5 text-left font-mono text-xs hover:bg-[hsl(var(--accent))]"
+              >
+                {child.value}
+              </button>
+            ))
+          ) : granularity === maxLevel ? (
+            <p className="px-2 py-3 text-xs text-muted-foreground">
+              {t("memory.scopeHierarchy.exactRunSelected")}
+            </p>
+          ) : (
+            <p className="px-2 py-3 text-xs text-muted-foreground">
+              {t("memory.scopeCombobox.empty")}
+            </p>
+          )}
+        </div>
+      )}
+
+      {allowPartial && !isSearching ? (
+        <Button
+          type="button"
+          size="sm"
+          variant="secondary"
+          className="w-full"
+          onClick={() => onApply(scopeAtLevel(draft, granularity))}
+        >
+          {granularity === "all"
+            ? t("memory.scopeHierarchy.applyAll")
+            : t("memory.scopeHierarchy.applyCurrentRange", {
+                range: t(RANGE_KEY[granularity]),
+              })}
+        </Button>
+      ) : null}
+
+      {truncated ? (
+        <p className="border-t px-2 pt-2 text-[10px] text-amber-700 dark:text-amber-300">
+          {t("memory.scopeHierarchy.inventoryIncomplete", {
+            count: scopes.length,
+          })}
+        </p>
+      ) : null}
+    </div>
+  );
+}