@tablestore/tablestore-agent-cli 0.2.11 → 0.4.0

package/dist/dashboard-runtime/dashboard/src/lib/browser-file-memory.ts

@@ -2,64 +2,42 @@
 
 import type { ChatMemoryWriteScope } from "@/components/chat/chat-config-context";
 import {
-  listFileMemories as listFileMemoriesService,
-  readFileMemory as readFileMemoryService,
+  getItem as getItemService,
+  listItems as listItemsService,
 } from "@/services/file-memory";
-import type { FileMemory, FileMemoryScope } from "@/types/file-memory";
+import {
+  FileMemoryCache,
+  fileMemoryCacheKey,
+  MAX_FILE_MEMORY_BYTES,
+  MAX_FILE_MEMORY_FILES,
+  MAX_FILE_MEMORY_SNAPSHOTS,
+  type FileMemoryCacheSummary,
+  type FileMemoryEntry,
+  type FileMemoryHit,
+  type FileMemoryTransport,
+  normalizeFileMemoryScope,
+  normalizeFileMemoryStoreName,
+} from "@/lib/file-memory-core";
 
 export const BROWSER_FILE_MEMORY_LABEL =
-  "标签页内容缓存 · 通过文件 API 按 SHA 复用";
-export const MAX_BROWSER_FILE_MEMORY_FILES = 300;
-export const MAX_BROWSER_FILE_MEMORY_BYTES = 3 * 1024 * 1024;
-export const MAX_BROWSER_FILE_MEMORY_SNAPSHOTS = 8;
-
-const LIST_PAGE_SIZE = 100;
-const READ_CONCURRENCY = 8;
-const MAX_LIST_PAGES = 1_000;
-const SNIPPET_LINES = 10;
-
-export interface BrowserFileMemoryEntry {
-  rel: string;
-  size: number;
-  sha256: string;
-}
-
-export interface BrowserFileMemoryHit {
-  text: string;
-  source: string;
-  score: number;
-}
+  "标签页内容缓存 · 通过 Item API 按 SHA 复用";
+export const MAX_BROWSER_FILE_MEMORY_FILES = MAX_FILE_MEMORY_FILES;
+export const MAX_BROWSER_FILE_MEMORY_BYTES = MAX_FILE_MEMORY_BYTES;
+export const MAX_BROWSER_FILE_MEMORY_SNAPSHOTS = MAX_FILE_MEMORY_SNAPSHOTS;
 
-export interface BrowserFileMemoryCacheSummary {
-  ok: boolean;
-  listed: number;
-  loaded: number;
-  reused: number;
-  totalBytes: number;
-  truncated: boolean;
-  error?: string;
-}
-
-interface CachedFile extends BrowserFileMemoryEntry {
-  path: string;
-  memoryId: string;
-  text: string;
-}
-
-interface BrowserFileMemorySnapshot {
-  files: Map<string, CachedFile>;
-  updatedAt: number;
-}
+export type BrowserFileMemoryEntry = FileMemoryEntry;
+export type BrowserFileMemoryHit = FileMemoryHit;
+export type BrowserFileMemoryCacheSummary = FileMemoryCacheSummary;
 
-type ListFileMemories = typeof listFileMemoriesService;
-type ReadFileMemory = typeof readFileMemoryService;
+type ListItems = typeof listItemsService;
+type GetItem = typeof getItemService;
 
 export interface LoadBrowserFileMemoryOptions {
   dataScopeKey: string;
   memoryStoreName: string;
   scope: ChatMemoryWriteScope;
-  listFileMemories?: ListFileMemories;
-  readFileMemory?: ReadFileMemory;
+  listItems?: ListItems;
+  getItem?: GetItem;
 }
 
 export interface LoadBrowserFileMemoryResult {
@@ -68,292 +46,48 @@ export interface LoadBrowserFileMemoryResult {
   cache: BrowserFileMemoryCacheSummary;
 }
 
-const snapshots = new Map<string, BrowserFileMemorySnapshot>();
-const inflight = new Map<string, Promise<LoadBrowserFileMemoryResult>>();
-
-function readSnapshot(key: string): BrowserFileMemorySnapshot | undefined {
-  const snapshot = snapshots.get(key);
-  if (snapshot) {
-    snapshots.delete(key);
-    snapshots.set(key, snapshot);
-  }
-  return snapshot;
-}
-
-function storeSnapshot(key: string, snapshot: BrowserFileMemorySnapshot): void {
-  snapshots.delete(key);
-  snapshots.set(key, snapshot);
-  while (snapshots.size > MAX_BROWSER_FILE_MEMORY_SNAPSHOTS) {
-    const oldestKey = snapshots.keys().next().value;
-    if (oldestKey === undefined) break;
-    snapshots.delete(oldestKey);
-  }
-}
-
-function normalizeScope(scope: ChatMemoryWriteScope): FileMemoryScope {
-  const read = (value: string, field: string) => {
-    const normalized = value.trim();
-    if (!normalized || normalized === "*") {
-      throw new Error(`file memory requires an exact ${field}`);
-    }
-    return normalized;
-  };
-  return {
-    appId: read(scope.appId, "appId"),
-    tenantId: read(scope.tenantId, "tenantId"),
-    agentId: read(scope.agentId, "agentId"),
-    runId: read(scope.runId, "runId"),
-  };
-}
+const cache = new FileMemoryCache();
 
 export function browserFileMemoryKey(opts: {
   dataScopeKey: string;
   memoryStoreName: string;
   scope: ChatMemoryWriteScope;
 }): string {
-  const scope = normalizeScope(opts.scope);
-  return JSON.stringify([
+  return fileMemoryCacheKey(
     opts.dataScopeKey,
     opts.memoryStoreName,
-    scope.appId,
-    scope.tenantId,
-    scope.agentId,
-    scope.runId,
-  ]);
-}
-
-function normalizePath(path: string): { path: string; rel: string } {
-  const absolute = `/${path.trim().replace(/^\/+/, "")}`;
-  const parts = absolute.slice(1).split("/");
-  if (
-    absolute === "/" ||
-    absolute.includes("\\") ||
-    parts.some((part) => !part || part === "." || part === "..")
-  ) {
-    throw new Error(`invalid file-memory path: ${path}`);
-  }
-  return { path: absolute, rel: parts.join("/") };
-}
-
-function validateMetadata(file: FileMemory): void {
-  normalizePath(file.path);
-  if (
-    !file.memoryId ||
-    !file.contentSha256 ||
-    !Number.isSafeInteger(file.contentSizeBytes) ||
-    file.contentSizeBytes < 0
-  ) {
-    throw new Error(`invalid file-memory metadata: ${file.path}`);
-  }
-}
-
-async function collectMetadata(
-  opts: LoadBrowserFileMemoryOptions,
-  scope: FileMemoryScope,
-): Promise<{ files: FileMemory[]; truncated: boolean }> {
-  const list = opts.listFileMemories ?? listFileMemoriesService;
-  const files = new Map<string, FileMemory>();
-  const tokens = new Set<string>();
-  let nextToken: string | undefined;
-  let truncated = false;
-
-  for (let page = 0; page < MAX_LIST_PAGES; page += 1) {
-    const response = await list(opts.memoryStoreName, {
-      scope,
-      limit: LIST_PAGE_SIZE,
-      ...(nextToken ? { nextToken } : {}),
-    });
-    for (const [index, file] of response.memories.entries()) {
-      validateMetadata(file);
-      const { path } = normalizePath(file.path);
-      if (!files.has(path)) files.set(path, { ...file, path });
-      if (files.size >= MAX_BROWSER_FILE_MEMORY_FILES) {
-        truncated =
-          index < response.memories.length - 1 || !!response.nextToken;
-        return { files: [...files.values()], truncated };
-      }
-    }
-    if (!response.nextToken) return { files: [...files.values()], truncated };
-    if (tokens.has(response.nextToken)) {
-      throw new Error("ListFileMemories repeated a pagination token");
-    }
-    tokens.add(response.nextToken);
-    nextToken = response.nextToken;
-  }
-  throw new Error("ListFileMemories exceeded the pagination limit");
-}
-
-async function mapConcurrent<T, TResult>(
-  items: T[],
-  concurrency: number,
-  worker: (item: T) => Promise<TResult>,
-): Promise<TResult[]> {
-  const results = new Array<TResult>(items.length);
-  let cursor = 0;
-  await Promise.all(
-    Array.from({ length: Math.min(concurrency, items.length) }, async () => {
-      while (cursor < items.length) {
-        const index = cursor;
-        cursor += 1;
-        results[index] = await worker(items[index]);
-      }
-    }),
+    normalizeFileMemoryScope(opts.scope),
   );
-  return results;
-}
-
-function snapshotEntries(
-  snapshot: BrowserFileMemorySnapshot | undefined,
-): BrowserFileMemoryEntry[] {
-  if (!snapshot) return [];
-  return [...snapshot.files.values()]
-    .map(({ rel, size, sha256 }) => ({ rel, size, sha256 }))
-    .sort((a, b) => a.rel.localeCompare(b.rel));
-}
-
-async function performLoad(
-  opts: LoadBrowserFileMemoryOptions,
-  key: string,
-  scope: FileMemoryScope,
-): Promise<LoadBrowserFileMemoryResult> {
-  const previous = readSnapshot(key);
-  try {
-    const collected = await collectMetadata(opts, scope);
-    const selected: FileMemory[] = [];
-    let totalBytes = 0;
-    let truncated = collected.truncated;
-    for (const file of collected.files) {
-      if (totalBytes + file.contentSizeBytes > MAX_BROWSER_FILE_MEMORY_BYTES) {
-        truncated = true;
-        continue;
-      }
-      selected.push(file);
-      totalBytes += file.contentSizeBytes;
-    }
-
-    const candidate = new Map<string, CachedFile>();
-    const toRead: FileMemory[] = [];
-    let reused = 0;
-    for (const file of selected) {
-      const { rel } = normalizePath(file.path);
-      const cached = previous?.files.get(rel);
-      if (cached?.sha256 === file.contentSha256) {
-        candidate.set(rel, {
-          ...cached,
-          path: file.path,
-          memoryId: file.memoryId,
-          size: file.contentSizeBytes,
-        });
-        reused += 1;
-      } else {
-        toRead.push(file);
-      }
-    }
-
-    const read = opts.readFileMemory ?? readFileMemoryService;
-    const loaded = await mapConcurrent(
-      toRead,
-      READ_CONCURRENCY,
-      async (file) => {
-        const response = await read(opts.memoryStoreName, {
-          scope,
-          path: file.path,
-        });
-        if (response.content === undefined) {
-          throw new Error(`ReadFileMemory omitted content for ${file.path}`);
-        }
-        const { path, rel } = normalizePath(file.path);
-        return {
-          path,
-          rel,
-          memoryId: file.memoryId,
-          size: file.contentSizeBytes,
-          sha256: file.contentSha256,
-          text: response.content,
-        } satisfies CachedFile;
-      },
-    );
-    for (const file of loaded) candidate.set(file.rel, file);
-
-    const snapshot = { files: candidate, updatedAt: Date.now() };
-    storeSnapshot(key, snapshot);
-    return {
-      key,
-      files: snapshotEntries(snapshot),
-      cache: {
-        ok: true,
-        listed: collected.files.length,
-        loaded: loaded.length,
-        reused,
-        totalBytes,
-        truncated,
-      },
-    };
-  } catch (error) {
-    const files = snapshotEntries(previous);
-    return {
-      key,
-      files,
-      cache: {
-        ok: false,
-        listed: files.length,
-        loaded: 0,
-        reused: files.length,
-        totalBytes: files.reduce((sum, file) => sum + file.size, 0),
-        truncated: false,
-        error: error instanceof Error ? error.message : String(error),
-      },
-    };
-  }
 }
 
 export function loadBrowserFileMemory(
   opts: LoadBrowserFileMemoryOptions,
 ): Promise<LoadBrowserFileMemoryResult> {
-  const scope = normalizeScope(opts.scope);
-  const key = browserFileMemoryKey({ ...opts, scope });
-  const existing = inflight.get(key);
-  if (existing) return existing;
-  const run = performLoad(opts, key, scope).finally(() => inflight.delete(key));
-  inflight.set(key, run);
-  return run;
+  const scope = normalizeFileMemoryScope(opts.scope);
+  const memoryStoreName = normalizeFileMemoryStoreName(opts.memoryStoreName);
+  const key = browserFileMemoryKey({ ...opts, memoryStoreName, scope });
+  const list = opts.listItems ?? listItemsService;
+  const get = opts.getItem ?? getItemService;
+  const transport: FileMemoryTransport = {
+    async listItems(request) {
+      const { memoryStoreName, ...input } = request;
+      return list(memoryStoreName, input);
+    },
+    async getItem(request) {
+      const { memoryStoreName, ...input } = request;
+      return get(memoryStoreName, input);
+    },
+  };
+  return cache.load({
+    key,
+    memoryStoreName,
+    scope,
+    transport,
+  });
 }
 
 export function readBrowserFileMemoryFile(key: string, rel: string): string {
-  const normalized = normalizePath(rel).rel;
-  const file = readSnapshot(key)?.files.get(normalized);
-  if (!file) throw new Error(`browser file-memory file not found: ${rel}`);
-  return file.text;
-}
-
-function tokenizeQuery(query: string): string[] {
-  const terms = new Set<string>();
-  for (const token of query.toLowerCase().match(/[a-z0-9]+/g) ?? []) {
-    if (token.length >= 2) terms.add(token);
-  }
-  for (const run of query.match(/[一-鿿㐀-䶿]+/g) ?? []) {
-    for (const char of run) terms.add(char);
-    for (let index = 0; index + 1 < run.length; index += 1) {
-      terms.add(run[index] + run[index + 1]);
-    }
-  }
-  return [...terms];
-}
-
-function scoreSnippet(
-  text: string,
-  terms: string[],
-  fullQuery: string,
-): number {
-  const lower = text.toLowerCase();
-  const matched = terms.reduce(
-    (count, term) => count + (lower.includes(term) ? 1 : 0),
-    0,
-  );
-  if (!matched) return 0;
-  const bonus =
-    fullQuery.length > 4 && lower.includes(fullQuery.toLowerCase()) ? 0.1 : 0;
-  return Math.min(1, matched / Math.max(1, terms.length) + bonus);
+  return cache.readFile(key, rel);
 }
 
 export function searchBrowserFileMemory(opts: {
@@ -361,31 +95,9 @@ export function searchBrowserFileMemory(opts: {
   query: string;
   topK: number;
 }): { results: BrowserFileMemoryHit[]; skipped?: boolean } {
-  const query = opts.query.trim();
-  const snapshot = readSnapshot(opts.key);
-  const terms = tokenizeQuery(query);
-  if (!query || !snapshot || terms.length === 0) {
-    return { results: [], skipped: true };
-  }
-  const hits: BrowserFileMemoryHit[] = [];
-  for (const file of snapshot.files.values()) {
-    const lines = file.text.split("\n");
-    for (let index = 0; index < lines.length; index += SNIPPET_LINES) {
-      const text = lines
-        .slice(index, index + SNIPPET_LINES)
-        .join("\n")
-        .trim();
-      if (!text) continue;
-      const score = scoreSnippet(text, terms, query);
-      if (score > 0) hits.push({ text, source: file.rel, score });
-    }
-  }
-  hits.sort((a, b) => b.score - a.score || a.source.localeCompare(b.source));
-  const topK = Math.max(1, Math.min(50, Math.trunc(opts.topK) || 1));
-  return { results: hits.slice(0, topK) };
+  return cache.search(opts);
 }
 
 export function clearBrowserFileMemoryForTests(): void {
-  snapshots.clear();
-  inflight.clear();
+  cache.clear();
 }

package/dist/dashboard-runtime/dashboard/src/lib/chat-scope-entry.ts

@@ -0,0 +1,59 @@
+import { parseExactScope } from "@/lib/scope-workspace";
+import type { FileMemoryScope } from "@/types/file-memory";
+
+export type ChatScopeStorageMode = "ots" | "file+ots";
+export type ChatScopeWikiPolicy = "auto" | "off";
+
+export interface ChatScopeEntry {
+  memoryStoreName: string;
+  storageMode: ChatScopeStorageMode;
+  scope: FileMemoryScope;
+  wiki: ChatScopeWikiPolicy;
+}
+
+export function resolveChatScopeStorageMode(
+  value: unknown,
+): ChatScopeStorageMode | undefined {
+  if (value === "ots") return "ots";
+  if (value === "file+ots" || value === "oss+ots") return "file+ots";
+  return undefined;
+}
+
+export function parseChatScopeEntry(
+  params: URLSearchParams,
+): ChatScopeEntry | null {
+  const memoryStoreName = params.get("memoryStoreName")?.trim() ?? "";
+  const storageMode = params.get("storageMode");
+  const scope = parseExactScope(params);
+  const wiki = params.get("wiki");
+
+  if (
+    !memoryStoreName ||
+    (storageMode !== "ots" && storageMode !== "file+ots") ||
+    !scope ||
+    (wiki !== "auto" && wiki !== "off")
+  ) {
+    return null;
+  }
+
+  return { memoryStoreName, storageMode, scope, wiki };
+}
+
+export type ChatScopeHydrationDecision =
+  { action: "hydrate"; enableWiki: boolean } | { action: "ignore" };
+
+export function decideChatScopeHydration(input: {
+  entry: ChatScopeEntry;
+  activeSessionId: string | null;
+  messageCount: number;
+  wikiReady: boolean;
+  handled: boolean;
+}): ChatScopeHydrationDecision {
+  if (input.handled || input.activeSessionId || input.messageCount > 0) {
+    return { action: "ignore" };
+  }
+  return {
+    action: "hydrate",
+    enableWiki: input.entry.wiki === "auto" && input.wikiReady,
+  };
+}

package/dist/dashboard-runtime/dashboard/src/lib/dream-create-options.ts

@@ -0,0 +1,27 @@
+import type { DreamApplyMode, DreamEffort } from "@/types/memory";
+
+export const DREAM_APPLICATION_MODES = [
+  { value: "proposal", forcedEffort: "low" },
+  { value: "safe_auto", forcedEffort: undefined },
+  { value: "plan", forcedEffort: "high" },
+] as const satisfies ReadonlyArray<{
+  value: DreamApplyMode;
+  forcedEffort: DreamEffort | undefined;
+}>;
+
+export function dreamModeForcedEffort(
+  applyMode: DreamApplyMode,
+): DreamEffort | undefined {
+  return DREAM_APPLICATION_MODES.find((mode) => mode.value === applyMode)
+    ?.forcedEffort;
+}
+
+export function normalizeDreamMode(
+  applyMode: DreamApplyMode,
+  effort: DreamEffort,
+): { applyMode: DreamApplyMode; effort: DreamEffort } {
+  return {
+    applyMode,
+    effort: dreamModeForcedEffort(applyMode) ?? effort,
+  };
+}