@tablestore/tablestore-agent-cli 0.1.9 → 0.2.1

package/dist/dashboard-runtime/dashboard/src/components/ui/usage-card.tsx

@@ -0,0 +1,43 @@
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+interface UsageItem {
+  label: React.ReactNode
+  value: React.ReactNode
+}
+
+interface UsageCardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+  title?: React.ReactNode
+  items: UsageItem[]
+}
+
+export function UsageCard({
+  title = "Usage",
+  items,
+  className,
+  ...props
+}: UsageCardProps) {
+  return (
+    <div
+      className={cn(
+        "rounded-md bg-[hsl(var(--background))] p-3 text-xs",
+        className,
+      )}
+      {...props}
+    >
+      <div className="mb-1.5 font-semibold text-[hsl(var(--muted-foreground))]">
+        {title}
+      </div>
+      {items.map((item, i) => (
+        <div
+          key={i}
+          className="flex justify-between text-[hsl(var(--subtle))] last:mb-0"
+        >
+          <span>{item.label}</span>
+          <span>{item.value}</span>
+        </div>
+      ))}
+    </div>
+  )
+}

package/dist/dashboard-runtime/dashboard/src/config/navigation.ts

@@ -1,5 +1,11 @@
 import type { LucideIcon } from "lucide-react";
-import { Brain, Database, MessageSquare, Sparkles } from "lucide-react";
+import {
+  Brain,
+  Database,
+  FolderKanban,
+  MessageSquare,
+  Sparkles,
+} from "lucide-react";
 
 export interface NavItem {
   title: string;
@@ -15,23 +21,58 @@ export interface SidebarNavItem {
   tooltip?: string;
 }
 
+export interface SidebarGroup {
+  /** Group heading shown above the items (uppercase tracking small caps in UI). */
+  title: string;
+  items: SidebarNavItem[];
+}
+
 /**
- * Primary navigation shown in the sidebar main section.
+ * Sidebar groups in webUI order. Only routes that the dashboard actually
+ * implements appear here — `/projects` lands under ACCOUNT alongside the
+ * model configuration entry, mirroring webUI's "ACCOUNT" section.
  */
-export const sidebarNav: SidebarNavItem[] = [
-  { title: "对话", href: "/chat", icon: MessageSquare },
-  { title: "知识库", href: "/knowledge-base", icon: Database },
-  { title: "记忆库", href: "/memory", icon: Brain },
-  { title: "大模型", href: "/llm-providers", icon: Sparkles },
+export const sidebarGroups: SidebarGroup[] = [
+  {
+    title: "对话",
+    items: [
+      { title: "对话智能体", href: "/chat", icon: MessageSquare },
+    ],
+  },
+  {
+    title: "知识库",
+    items: [
+      { title: "知识库管理", href: "/knowledge-base", icon: Database },
+    ],
+  },
+  {
+    title: "记忆库",
+    items: [
+      { title: "记忆库管理", href: "/memory", icon: Brain },
+    ],
+  },
+  {
+    title: "配置",
+    items: [
+      { title: "模型提供商", href: "/llm-providers", icon: Sparkles },
+      { title: "项目管理", href: "/projects", icon: FolderKanban },
+    ],
+  },
 ];
 
 /**
- * Secondary sidebar group reserved for future resource entries.
+ * Flat list derived from the grouped structure. Kept exported because the
+ * mobile sidebar and a handful of legacy callers iterate the flat sequence.
  */
+export const sidebarNav: SidebarNavItem[] = sidebarGroups.flatMap(
+  (group) => group.items,
+);
+
+/** @deprecated retained for backwards compatibility — moved into `sidebarGroups`. */
 export const sidebarResources: SidebarNavItem[] = [];
 
 /**
- * @deprecated Kept for backwards compatibility; prefer `sidebarNav`.
+ * @deprecated Kept for backwards compatibility; prefer `sidebarGroups`.
  */
 export const mainNav: NavItem[] = [
   { title: "知识库", href: "/knowledge-base" },

package/dist/dashboard-runtime/dashboard/src/hooks/use-detail-sidebar-collapsed.ts

@@ -0,0 +1,86 @@
+"use client";
+
+import { useCallback, useSyncExternalStore } from "react";
+
+/**
+ * Mirror of {@link useSidebarCollapsed} for the *secondary* (detail-page)
+ * sidebar. Same persistence + cross-instance + cross-tab sync pattern, with
+ * a separate localStorage key so the two sidebars collapse independently.
+ *
+ * The reason for two hooks rather than one with a key parameter: each
+ * useSyncExternalStore needs a stable subscribe / snapshot pair, and a
+ * single subscribe shared between two state slots would notify all
+ * consumers on every change. Splitting keeps the dependency graph clean
+ * and avoids the "primary toggle re-renders every detail page" gotcha.
+ */
+const STORAGE_KEY = "detail-sidebar.collapsed";
+const EVENT_NAME = "detail-sidebar-collapsed-change";
+
+let cachedValue: boolean | null = null;
+
+function readFromStorage(): boolean {
+  if (cachedValue !== null) return cachedValue;
+  if (typeof window === "undefined") {
+    cachedValue = false;
+    return false;
+  }
+  try {
+    cachedValue = window.localStorage.getItem(STORAGE_KEY) === "1";
+  } catch {
+    cachedValue = false;
+  }
+  return cachedValue;
+}
+
+function subscribe(notify: () => void): () => void {
+  if (typeof window === "undefined") return () => {};
+  const handler = (event: Event) => {
+    const detail = (event as CustomEvent<boolean>).detail;
+    cachedValue = Boolean(detail);
+    notify();
+  };
+  const onStorage = (event: StorageEvent) => {
+    if (event.key !== STORAGE_KEY) return;
+    cachedValue = event.newValue === "1";
+    notify();
+  };
+  window.addEventListener(EVENT_NAME, handler as EventListener);
+  window.addEventListener("storage", onStorage);
+  return () => {
+    window.removeEventListener(EVENT_NAME, handler as EventListener);
+    window.removeEventListener("storage", onStorage);
+  };
+}
+
+function getSnapshot(): boolean {
+  return readFromStorage();
+}
+
+// During SSR the detail sidebar starts expanded; hydration reconciles.
+function getServerSnapshot(): boolean {
+  return false;
+}
+
+export function useDetailSidebarCollapsed() {
+  const collapsed = useSyncExternalStore(
+    subscribe,
+    getSnapshot,
+    getServerSnapshot,
+  );
+
+  const setCollapsed = useCallback((next: boolean) => {
+    cachedValue = next;
+    try {
+      window.localStorage.setItem(STORAGE_KEY, next ? "1" : "0");
+    } catch {
+      // Ignore — private mode / quota / etc.
+    }
+    window.dispatchEvent(new CustomEvent(EVENT_NAME, { detail: next }));
+  }, []);
+
+  const toggle = useCallback(() => {
+    setCollapsed(!readFromStorage());
+  }, [setCollapsed]);
+
+  return { collapsed, setCollapsed, toggle };
+}

package/dist/dashboard-runtime/dashboard/src/hooks/use-oss-import.ts

@@ -0,0 +1,148 @@
+import { useCallback, useState } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import {
+  addDocuments,
+  UPLOAD_TIMEOUT_MS,
+  type AddDocumentItem,
+  type DocumentOperationResult,
+} from "@/services/documents";
+import { invalidateKnowledgeBaseQueries } from "@/lib/query-keys";
+
+export interface OssImportProgress {
+  phase: "upload" | "done";
+  totalItems: number;
+  completedItems: number;
+  errors: string[];
+}
+
+interface OssImportVariables {
+  knowledgeBaseName: string;
+  /** ossKeys for individually-checked files. Submitted as-is, no filters. */
+  fileKeys: string[];
+  /** Folder prefixes (ending with `/`). Server recurses; filters apply. */
+  folderPrefixes: string[];
+  /** Glob arrays produced by `lib/glob-filter.ts`. Sent to the server only
+   *  on folder items — file items don't carry filters. */
+  inclusionFilters?: string[];
+  exclusionFilters?: string[];
+  subspace?: string;
+  metadata?: Record<string, unknown>;
+}
+
+const SUBMISSION_BATCH_SIZE = 10; // matches services/documents.ts BATCH_SIZE
+
+/**
+ * Submit an OSS-mode import to the KB.
+ *
+ * The KB API natively accepts a folder ossKey (`oss://<bucket>/docs/2026/`)
+ * and recurses on the server side, so the client doesn't need to expand
+ * folders into individual keys. Each {@link OssSelection} item becomes one
+ * `AddDocumentItem`:
+ *
+ *   - file selection   → `{ ossKey }`                    (no filters)
+ *   - folder selection → `{ ossKey, inclusionFilters?, exclusionFilters? }`
+ *
+ * The full document list is submitted via `addDocuments`, which already
+ * handles `BATCH_SIZE` chunking internally. We re-batch here only because
+ * we want incremental progress — `addDocuments` doesn't expose a callback.
+ *
+ * Per-batch failures are tolerated: surviving batches' results are kept and
+ * the failed slice is recorded as `status: "failed"` per ossKey. This
+ * mirrors `useUploadDocuments`'s tolerance for partial-failure import.
+ */
+export function useOssImport() {
+  const queryClient = useQueryClient();
+  const [progress, setProgress] = useState<OssImportProgress | null>(null);
+
+  const resetProgress = useCallback(() => setProgress(null), []);
+
+  const mutation = useMutation({
+    mutationFn: async (vars: OssImportVariables) => {
+      // Build the AddDocumentItem list. Filters attach only to folder items —
+      // a checked file is an explicit user intent and bypasses include/exclude
+      // (matches the local-folder semantics).
+      const items: AddDocumentItem[] = [
+        ...vars.fileKeys.map<AddDocumentItem>((ossKey) => ({
+          ossKey,
+          ...(vars.metadata ? { metadata: vars.metadata } : {}),
+        })),
+        ...vars.folderPrefixes.map<AddDocumentItem>((ossKey) => ({
+          ossKey,
+          ...(vars.metadata ? { metadata: vars.metadata } : {}),
+          ...(vars.inclusionFilters
+            ? { inclusionFilters: vars.inclusionFilters }
+            : {}),
+          ...(vars.exclusionFilters
+            ? { exclusionFilters: vars.exclusionFilters }
+            : {}),
+        })),
+      ];
+
+      if (items.length === 0) {
+        setProgress({ phase: "done", totalItems: 0, completedItems: 0, errors: [] });
+        return { documentDetails: [] as DocumentOperationResult[] };
+      }
+
+      setProgress({
+        phase: "upload",
+        totalItems: items.length,
+        completedItems: 0,
+        errors: [],
+      });
+
+      const allResults: DocumentOperationResult[] = [];
+      const allErrors: string[] = [];
+      for (let i = 0; i < items.length; i += SUBMISSION_BATCH_SIZE) {
+        const slice = items.slice(i, i + SUBMISSION_BATCH_SIZE);
+        try {
+          const resp = await addDocuments(
+            {
+              knowledgeBaseName: vars.knowledgeBaseName,
+              subspace: vars.subspace,
+              documents: slice,
+            },
+            { timeoutMs: UPLOAD_TIMEOUT_MS },
+          );
+          allResults.push(...resp.documentDetails);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          allErrors.push(`批次 ${Math.floor(i / SUBMISSION_BATCH_SIZE) + 1}: ${message}`);
+          for (const item of slice) {
+            allResults.push({
+              ossKey: item.ossKey,
+              status: "failed",
+              failureReason: message,
+            });
+          }
+        }
+        setProgress((p) =>
+          p
+            ? {
+                ...p,
+                completedItems: Math.min(p.totalItems, p.completedItems + slice.length),
+              }
+            : p,
+        );
+      }
+
+      setProgress({
+        phase: "done",
+        totalItems: items.length,
+        completedItems: items.length,
+        errors: allErrors,
+      });
+      return { documentDetails: allResults };
+    },
+    onSuccess: () => {
+      invalidateKnowledgeBaseQueries(queryClient);
+    },
+    onSettled: () => {
+      // Match the local upload hook's "linger briefly so the user reads the
+      // final state" gesture before clearing.
+      setTimeout(resetProgress, 300);
+    },
+  });
+
+  return { ...mutation, progress };
+}

package/dist/dashboard-runtime/dashboard/src/hooks/use-oss-list.ts

@@ -0,0 +1,89 @@
+import { useInfiniteQuery } from "@tanstack/react-query";
+
+import {
+  listOssObjects,
+  type OssListFile,
+  type OssListFolder,
+  type OssListPage,
+} from "@/services/oss";
+
+interface UseOssListOptions {
+  prefix: string;
+  search?: string;
+  /** When false, pauses fetching — useful while the parent tab is hidden. */
+  enabled?: boolean;
+}
+
+export interface UseOssListResult {
+  folders: OssListFolder[];
+  files: OssListFile[];
+  isLoading: boolean;
+  isFetchingNextPage: boolean;
+  hasNextPage: boolean;
+  fetchNextPage: () => void;
+  refetch: () => void;
+  error: Error | null;
+  /** Forwarded so the UI can render the "OSS_FORBIDDEN / NOT_CONFIGURED" state. */
+  errorCode: string | null;
+}
+
+const PAGE_SIZE = 100;
+
+/**
+ * Query key shape mirrors `lib/query-keys.ts` conventions: a stable string
+ * head plus the variable identifiers. Co-located with the hook because no
+ * other module needs to invalidate this cache (the page is read-only).
+ */
+function queryKey(prefix: string, search: string) {
+  return ["oss-list", prefix, search] as const;
+}
+
+export function useOssList(options: UseOssListOptions): UseOssListResult {
+  const { prefix, search = "", enabled = true } = options;
+
+  const query = useInfiniteQuery<OssListPage, Error>({
+    queryKey: queryKey(prefix, search),
+    queryFn: ({ pageParam }) =>
+      listOssObjects({
+        prefix,
+        continuationToken: typeof pageParam === "string" ? pageParam : undefined,
+        maxResults: PAGE_SIZE,
+        search: search || undefined,
+      }),
+    getNextPageParam: (last) => last.nextContinuationToken ?? undefined,
+    initialPageParam: undefined,
+    enabled,
+    // Listings are invalidated by re-mounting the dialog, not by mutations.
+    staleTime: 30_000,
+    refetchOnWindowFocus: false,
+  });
+
+  const folders: OssListFolder[] = [];
+  const files: OssListFile[] = [];
+  for (const page of query.data?.pages ?? []) {
+    folders.push(...page.folders);
+    files.push(...page.files);
+  }
+
+  // Surface error code from the standard envelope so the UI can switch on it.
+  const errorCode =
+    query.error && typeof query.error === "object" && "code" in query.error
+      ? String((query.error as { code: unknown }).code ?? "")
+      : null;
+
+  return {
+    folders,
+    files,
+    isLoading: query.isLoading,
+    isFetchingNextPage: query.isFetchingNextPage,
+    hasNextPage: Boolean(query.hasNextPage),
+    fetchNextPage: () => {
+      if (query.hasNextPage && !query.isFetchingNextPage) query.fetchNextPage();
+    },
+    refetch: () => {
+      void query.refetch();
+    },
+    error: query.error ?? null,
+    errorCode,
+  };
+}

package/dist/dashboard-runtime/dashboard/src/lib/extension-filter.ts

@@ -0,0 +1,62 @@
+/**
+ * Shared filename-extension and recursion rules used by both the local-folder
+ * upload mode and the server-side OSS prefix expansion. Keeping the rule shape
+ * and matching logic in one place is what guarantees the two paths agree.
+ *
+ * `include` / `exclude` are lowercase, dotted suffixes ([".md", ".pdf"]).
+ * They apply to the file's basename, not to its path — directory names never
+ * count toward the suffix check.
+ */
+export interface ExtensionRules {
+  include: string[];
+  exclude: string[];
+}
+
+export interface RecursiveExtensionRules extends ExtensionRules {
+  recursive: boolean;
+}
+
+/**
+ * Normalize a comma-separated extension list like ".md, pdf , .TXT" into a
+ * lowercase, dot-prefixed array: [".md", ".pdf", ".txt"]. Empty tokens are
+ * dropped; missing leading dots are added.
+ */
+export function parseExtensionList(raw: string): string[] {
+  return raw
+    .split(",")
+    .map((s) => s.trim().toLowerCase())
+    .filter(Boolean)
+    .map((ext) => (ext.startsWith(".") ? ext : `.${ext}`));
+}
+
+/** Pure name-based check. No path or depth involved — caller handles those. */
+export function matchesExtension(name: string, rules: ExtensionRules): boolean {
+  const lower = name.toLowerCase();
+  if (rules.include.length > 0 && !rules.include.some((ext) => lower.endsWith(ext))) {
+    return false;
+  }
+  if (rules.exclude.length > 0 && rules.exclude.some((ext) => lower.endsWith(ext))) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Filter a File[] picked through `<input webkitdirectory>` or drag-drop.
+ *
+ * The `webkitRelativePath` shape is "<root>/<...subpath>", so the top-level
+ * file inside the picked folder lives at depth 1. That's why the recursive
+ * cutoff here is `depth > 1` — anything deeper is a subdirectory.
+ */
+export function filterFolderFiles(
+  files: File[],
+  rules: RecursiveExtensionRules,
+): File[] {
+  return files.filter((file) => {
+    const rel = file.webkitRelativePath || file.name;
+    const depth = (rel.match(/\//g) || []).length;
+    if (!rules.recursive && depth > 1) return false;
+    return matchesExtension(file.name, rules);
+  });
+}
+

package/dist/dashboard-runtime/dashboard/src/lib/glob-filter.ts

@@ -0,0 +1,76 @@
+/**
+ * Translate user-friendly extension / prefix tokens into the glob patterns
+ * the KB server expects on `inclusionFilters` / `exclusionFilters`.
+ *
+ * The server only accepts one of two pattern shapes:
+ *   - prefix:  `value*` (wildcard at the END, anchors the start)
+ *   - suffix:  `*value` (wildcard at the START, anchors the end)
+ *
+ * The dashboard masks these details — users type plain text in the UI
+ * (e.g. ".md, .pdf" for suffix include; "archive/2026/, drafts/" for prefix
+ * include) and these helpers wrap them. Already-globbed input is detected
+ * and left alone, so a user who pastes "*.md" or "drafts/*" gets the same
+ * result as one who types ".md" or "drafts/".
+ */
+
+/**
+ * Lowercase, trim, and split a comma-separated input list. Empty tokens are
+ * dropped. Used by both prefix and suffix parsers below.
+ */
+function tokenize(raw: string): string[] {
+  return raw
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Wrap each token as a suffix glob: ".md, .pdf" → ["*.md", "*.pdf"].
+ *
+ * Idempotent — a token that already starts with `*` is kept verbatim, so
+ * users who type the canonical glob form don't get a double-star.
+ */
+export function parseSuffixGlobs(raw: string): string[] {
+  return tokenize(raw).map((token) => (token.startsWith("*") ? token : `*${token}`));
+}
+
+/**
+ * Wrap each token as a prefix glob: "drafts/, archive/2026/" →
+ * ["drafts/*", "archive/2026/*"].
+ *
+ * Idempotent on tokens already ending in `*`.
+ */
+export function parsePrefixGlobs(raw: string): string[] {
+  return tokenize(raw).map((token) => (token.endsWith("*") ? token : `${token}*`));
+}
+
+/**
+ * Combine prefix and suffix inclusion / exclusion inputs into the flat
+ * `inclusionFilters` / `exclusionFilters` arrays the server consumes.
+ * Returns `undefined` for empty buckets so callers can spread without
+ * leaking empty arrays into the request body.
+ */
+export interface FolderGlobInputs {
+  prefixIncludeInput: string;
+  prefixExcludeInput: string;
+  suffixIncludeInput: string;
+  suffixExcludeInput: string;
+}
+
+export function buildFolderGlobs(inputs: FolderGlobInputs): {
+  inclusionFilters?: string[];
+  exclusionFilters?: string[];
+} {
+  const inclusionFilters = [
+    ...parsePrefixGlobs(inputs.prefixIncludeInput),
+    ...parseSuffixGlobs(inputs.suffixIncludeInput),
+  ];
+  const exclusionFilters = [
+    ...parsePrefixGlobs(inputs.prefixExcludeInput),
+    ...parseSuffixGlobs(inputs.suffixExcludeInput),
+  ];
+  return {
+    inclusionFilters: inclusionFilters.length > 0 ? inclusionFilters : undefined,
+    exclusionFilters: exclusionFilters.length > 0 ? exclusionFilters : undefined,
+  };
+}

package/dist/dashboard-runtime/dashboard/src/lib/oss-selection.ts

@@ -0,0 +1,58 @@
+/**
+ * Discriminated selection algebra used by the OSS browser. Splitting the
+ * shape into a tagged union (instead of two parallel sets) keeps the
+ * "checked file" vs. "checked folder" distinction visible at every call
+ * site without bug-prone implicit-conversion paths.
+ */
+export type OssSelectedItem =
+  | { type: "file"; ossKey: string; size: number }
+  | { type: "folder"; prefix: string };
+
+export type OssSelection = OssSelectedItem[];
+
+export function isFileSelected(sel: OssSelection, ossKey: string): boolean {
+  return sel.some((s) => s.type === "file" && s.ossKey === ossKey);
+}
+
+export function isFolderSelected(sel: OssSelection, prefix: string): boolean {
+  return sel.some((s) => s.type === "folder" && s.prefix === prefix);
+}
+
+export function toggleFile(
+  sel: OssSelection,
+  file: { ossKey: string; size: number },
+): OssSelection {
+  if (isFileSelected(sel, file.ossKey)) {
+    return sel.filter((s) => !(s.type === "file" && s.ossKey === file.ossKey));
+  }
+  return [...sel, { type: "file", ossKey: file.ossKey, size: file.size }];
+}
+
+export function toggleFolder(
+  sel: OssSelection,
+  folder: { prefix: string },
+): OssSelection {
+  if (isFolderSelected(sel, folder.prefix)) {
+    return sel.filter((s) => !(s.type === "folder" && s.prefix === folder.prefix));
+  }
+  return [...sel, { type: "folder", prefix: folder.prefix }];
+}
+
+/**
+ * Split a selection into the two payloads consumers need at submission time:
+ * an explicit ossKey list (files), and the prefixes that need to go through
+ * `expandPrefixes()`. Order within each list is preserved so the UI can
+ * render a stable preview.
+ */
+export function partitionSelection(sel: OssSelection): {
+  fileKeys: string[];
+  folderPrefixes: string[];
+} {
+  const fileKeys: string[] = [];
+  const folderPrefixes: string[] = [];
+  for (const item of sel) {
+    if (item.type === "file") fileKeys.push(item.ossKey);
+    else folderPrefixes.push(item.prefix);
+  }
+  return { fileKeys, folderPrefixes };
+}