@tablestore/tablestore-agent-cli 0.2.11 → 0.4.0

package/dist/dashboard-runtime/dashboard/src/lib/memory-scope-history.ts

@@ -0,0 +1,165 @@
+import type { MemoryScope } from "@/types/memory";
+
+export const MAX_RECENT_MEMORY_SCOPES = 10;
+const STORAGE_KEY_PREFIX = "tsagent.memoryScopes.v1";
+
+type ScopeStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">;
+type OptionalScopeField = "tenantId" | "agentId" | "runId";
+
+const OPTIONAL_SCOPE_FIELDS: OptionalScopeField[] = [
+  "tenantId",
+  "agentId",
+  "runId",
+];
+
+export function getRecentMemoryScopeStorageKey(
+  dataScopeKey: string,
+  memoryStoreName: string,
+): string {
+  return `${STORAGE_KEY_PREFIX}:${JSON.stringify([dataScopeKey, memoryStoreName])}`;
+}
+
+export function isAllWildcardMemoryScope(
+  value: Partial<MemoryScope> | null | undefined,
+): boolean {
+  if (!value || typeof value.appId !== "string" || value.appId.trim() !== "*") {
+    return false;
+  }
+
+  return OPTIONAL_SCOPE_FIELDS.every((field) => {
+    const fieldValue = value[field];
+    if (fieldValue === undefined) return true;
+    if (typeof fieldValue !== "string") return false;
+    const normalized = fieldValue.trim();
+    return !normalized || normalized === "*";
+  });
+}
+
+export function normalizeRecentMemoryScope(
+  value: Partial<MemoryScope> | null | undefined,
+): MemoryScope | null {
+  if (!value || typeof value.appId !== "string" || !value.appId.trim()) {
+    return null;
+  }
+
+  const scope: MemoryScope = { appId: value.appId.trim() };
+  for (const field of OPTIONAL_SCOPE_FIELDS) {
+    const fieldValue = value[field];
+    if (typeof fieldValue === "string" && fieldValue.trim()) {
+      scope[field] = fieldValue.trim();
+    }
+  }
+
+  return isAllWildcardMemoryScope(scope) ? null : scope;
+}
+
+function scopeIdentity(scope: MemoryScope): string {
+  return JSON.stringify([
+    scope.appId,
+    scope.tenantId ?? "",
+    scope.agentId ?? "",
+    scope.runId ?? "",
+  ]);
+}
+
+export function readRecentMemoryScopes(
+  storage: Pick<ScopeStorage, "getItem">,
+  dataScopeKey: string,
+  memoryStoreName: string,
+): MemoryScope[] {
+  try {
+    const raw = storage.getItem(
+      getRecentMemoryScopeStorageKey(dataScopeKey, memoryStoreName),
+    );
+    if (!raw) return [];
+
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+
+    const identities = new Set<string>();
+    const scopes: MemoryScope[] = [];
+    for (const item of parsed) {
+      const value =
+        item && typeof item === "object"
+          ? (item as Partial<MemoryScope>)
+          : null;
+      if (isAllWildcardMemoryScope(value)) continue;
+
+      const scope = normalizeRecentMemoryScope(value);
+      if (!scope) continue;
+
+      const identity = scopeIdentity(scope);
+      if (identities.has(identity)) continue;
+      identities.add(identity);
+      scopes.push(scope);
+      if (scopes.length === MAX_RECENT_MEMORY_SCOPES) break;
+    }
+    return scopes;
+  } catch {
+    return [];
+  }
+}
+
+export function rememberRecentMemoryScope(
+  storage: Pick<ScopeStorage, "getItem" | "setItem">,
+  dataScopeKey: string,
+  memoryStoreName: string,
+  value: Partial<MemoryScope>,
+): MemoryScope[] {
+  const current = readRecentMemoryScopes(
+    storage,
+    dataScopeKey,
+    memoryStoreName,
+  );
+  if (isAllWildcardMemoryScope(value)) return current;
+
+  const scope = normalizeRecentMemoryScope(value);
+  if (!scope) return current;
+
+  const identity = scopeIdentity(scope);
+  const next = [
+    scope,
+    ...current.filter((item) => scopeIdentity(item) !== identity),
+  ].slice(0, MAX_RECENT_MEMORY_SCOPES);
+
+  try {
+    storage.setItem(
+      getRecentMemoryScopeStorageKey(dataScopeKey, memoryStoreName),
+      JSON.stringify(next),
+    );
+  } catch {
+    // Scope history must never block memory navigation.
+  }
+  return next;
+}
+
+export function clearRecentMemoryScopes(
+  storage: Pick<ScopeStorage, "removeItem">,
+  dataScopeKey: string,
+  memoryStoreName: string,
+): void {
+  try {
+    storage.removeItem(
+      getRecentMemoryScopeStorageKey(dataScopeKey, memoryStoreName),
+    );
+  } catch {
+    // Scope history must never block memory navigation.
+  }
+}
+
+export function excludeRecentMemoryScopes(
+  knownScopes: readonly MemoryScope[],
+  recentScopes: readonly MemoryScope[],
+): MemoryScope[] {
+  const recentIdentities = new Set(
+    recentScopes
+      .map(normalizeRecentMemoryScope)
+      .filter((scope): scope is MemoryScope => scope !== null)
+      .map(scopeIdentity),
+  );
+
+  return knownScopes.filter((scope) => {
+    const normalized = normalizeRecentMemoryScope(scope);
+    return !normalized || !recentIdentities.has(scopeIdentity(normalized));
+  });
+}

package/dist/dashboard-runtime/dashboard/src/lib/memory-storage-mode.ts

@@ -5,7 +5,15 @@ export type StorageMode = "ots" | "file+ots" | "filemem";
 export type MemoryInputType = "short-term" | "file";
 export type MemoryStorageStructure = "structured" | "file";
 export type MemoryDetailSegment =
-  "units" | "search" | "messages" | "tasks" | "requests" | "dream" | "settings";
+  | "scope"
+  | "units"
+  | "search"
+  | "messages"
+  | "tasks"
+  | "requests"
+  | "dream"
+  | "wiki"
+  | "settings";
 export type MemoryCardShortcut =
   "longTerm" | "shortTerm" | "extract" | "consolidate" | "files";
 export type MemoryCardAction = "units" | "search" | "settings";
@@ -37,15 +45,21 @@ export const STORAGE_MODE_VALUES: StorageMode[] = [
 ];
 
 const STRUCTURED_DETAIL_SEGMENTS: MemoryDetailSegment[] = [
+  "scope",
   "units",
   "search",
   "messages",
   "tasks",
   "requests",
   "dream",
+  "wiki",
+  "settings",
+];
+const FILE_DETAIL_SEGMENTS: MemoryDetailSegment[] = [
+  "units",
+  "wiki",
   "settings",
 ];
-const FILE_DETAIL_SEGMENTS: MemoryDetailSegment[] = ["units", "settings"];
 const STRUCTURED_CARD_SHORTCUTS: MemoryCardShortcut[] = [
   "longTerm",
   "shortTerm",
@@ -63,9 +77,16 @@ const FILE_CARD_ACTIONS: MemoryCardAction[] = ["units", "settings"];
 export function normalizeStorageMode(
   value: string | undefined | null,
 ): StorageMode {
-  if (value === "filemem") return "filemem";
+  return parseKnownStorageMode(value) ?? "ots";
+}
+
+export function parseKnownStorageMode(
+  value: string | undefined | null,
+): StorageMode | null {
+  if (value === "ots") return "ots";
   if (value === "file+ots" || value === "oss+ots") return "file+ots";
-  return "ots";
+  if (value === "filemem") return "filemem";
+  return null;
 }
 
 export function memoryStorageSelectionForInput(

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

@@ -53,6 +53,19 @@ export function formatScope(scope?: MemoryScope): string {
     .join(" / ");
 }
 
+/**
+ * Positional four-tuple label for the scope pickers. Unlike
+ * {@link formatScope}, an empty dimension keeps its slot as `—`, so rows line
+ * up column-wise in a dropdown and "no tenant" reads differently from "no
+ * agent". Shared by both pickers (ScopeCombobox and the ScopeBar) so their
+ * labels can't drift apart.
+ */
+export function scopeLabel(scope: MemoryScope): string {
+  return [scope.appId, scope.tenantId, scope.agentId, scope.runId]
+    .map((v) => v || "—")
+    .join(" / ");
+}
+
 /**
  * A set of dream tasks that share the same input scope.
  *

package/dist/dashboard-runtime/dashboard/src/lib/query-keys.ts

@@ -1,5 +1,6 @@
 import type { QueryClient, QueryKey } from "@tanstack/react-query";
 import type { FileMemoryScope } from "@/types/file-memory";
+import type { WikiScope } from "@/types/wiki";
 
 export const RUNTIME_CONTEXT_QUERY_KEY = ["runtime-context"] as const;
 export const PENDING_DATA_SCOPE_KEY = "pending";
@@ -29,50 +30,137 @@ export const fileMemoryQueryKeys = {
       "list",
       pathPrefix,
     ] as const,
-  file: (
+  item: (
     dataScopeKey: string,
     memoryStoreName: string,
     scope: FileMemoryScope,
-    path: string,
+    address: string,
   ) =>
     [
       ...fileMemoryQueryKeys.root(dataScopeKey, memoryStoreName, scope),
-      "file",
-      path,
+      "item",
+      address,
     ] as const,
   versions: (
     dataScopeKey: string,
     memoryStoreName: string,
     scope: FileMemoryScope,
-    memoryId: string,
-    path?: string,
+    itemId: string,
   ) =>
     [
       ...fileMemoryQueryKeys.root(dataScopeKey, memoryStoreName, scope),
       "versions",
-      memoryId,
-      path,
+      itemId,
     ] as const,
   version: (
     dataScopeKey: string,
     memoryStoreName: string,
     scope: FileMemoryScope,
-    memoryId: string,
-    memoryVersionId: string,
-    versionSeq: number,
+    versionId: string,
   ) =>
     [
       ...fileMemoryQueryKeys.root(dataScopeKey, memoryStoreName, scope),
       "version",
-      memoryId,
-      memoryVersionId,
-      versionSeq,
+      versionId,
+    ] as const,
+};
+
+export const wikiQueryKeys = {
+  root: (
+    dataScopeKey: string,
+    memoryStoreName: string,
+    scope: WikiScope | undefined,
+  ) =>
+    [
+      "wiki",
+      dataScopeKey,
+      memoryStoreName,
+      scope?.appId ?? "",
+      scope?.tenantId ?? "",
+      scope?.agentId ?? "",
+    ] as const,
+  detail: (dataScopeKey: string, memoryStoreName: string, scope: WikiScope) =>
+    [
+      ...wikiQueryKeys.root(dataScopeKey, memoryStoreName, scope),
+      "detail",
+    ] as const,
+  sources: (
+    dataScopeKey: string,
+    memoryStoreName: string,
+    scope: WikiScope,
+    limit?: number,
+  ) =>
+    [
+      ...wikiQueryKeys.root(dataScopeKey, memoryStoreName, scope),
+      "sources",
+      limit ?? null,
+    ] as const,
+  artifacts: (
+    dataScopeKey: string,
+    memoryStoreName: string,
+    scope: WikiScope,
+    kind: "skill" | "profile",
+    limit?: number,
+  ) =>
+    [
+      ...wikiQueryKeys.root(dataScopeKey, memoryStoreName, scope),
+      "artifacts",
+      kind,
+      limit ?? null,
+    ] as const,
+  source: (
+    dataScopeKey: string,
+    memoryStoreName: string,
+    scope: WikiScope,
+    path: string,
+  ) =>
+    [
+      ...wikiQueryKeys.root(dataScopeKey, memoryStoreName, scope),
+      "source",
+      path,
+    ] as const,
+  pages: (
+    dataScopeKey: string,
+    memoryStoreName: string,
+    scope: WikiScope,
+    limit?: number,
+  ) =>
+    [
+      ...wikiQueryKeys.root(dataScopeKey, memoryStoreName, scope),
+      "pages",
+      limit ?? null,
+    ] as const,
+  page: (
+    dataScopeKey: string,
+    memoryStoreName: string,
+    scope: WikiScope,
+    path: string,
+  ) =>
+    [
+      ...wikiQueryKeys.root(dataScopeKey, memoryStoreName, scope),
+      "page",
+      path,
+    ] as const,
+  search: (
+    dataScopeKey: string,
+    memoryStoreName: string,
+    scope: WikiScope,
+    query: string,
+    limit?: number,
+  ) =>
+    [
+      ...wikiQueryKeys.root(dataScopeKey, memoryStoreName, scope),
+      "search",
+      query,
+      limit ?? null,
     ] as const,
 };
 
 export const queryKeys = {
   runtimeContext: RUNTIME_CONTEXT_QUERY_KEY,
   instances: (scope: string) => ["instances", scope] as const,
+  instanceConnectivity: (scope: string) =>
+    ["instance-connectivity", scope] as const,
   instance: (scope: string, name: string | null | undefined) =>
     ["instance", scope, name] as const,
   knowledgeBases: (scope: string) => ["knowledge-bases", scope] as const,
@@ -318,6 +406,7 @@ const INSTANCE_SCOPED_QUERY_ROOTS = new Set([
   "knowledge-bases",
   "chunks",
   "memory",
+  "wiki",
   "llm-providers",
   "llm-provider-models",
   "api-keys",

package/dist/dashboard-runtime/dashboard/src/lib/retrieval-security.ts

@@ -0,0 +1,54 @@
+export type RetrievalSecurityCode = "UNAUTHORIZED" | "FORBIDDEN";
+export type RetrievalSecuritySource = "memory" | "wiki";
+
+function publicMessage(
+  source: RetrievalSecuritySource,
+  code: RetrievalSecurityCode,
+): string {
+  const label = source === "memory" ? "Memory" : "Wiki";
+  return code === "UNAUTHORIZED"
+    ? `${label} authentication failed`
+    : `${label} access is forbidden`;
+}
+
+export class FatalRetrievalSecurityError extends Error {
+  readonly source: RetrievalSecuritySource;
+  readonly code: RetrievalSecurityCode;
+
+  constructor(source: RetrievalSecuritySource, code: RetrievalSecurityCode) {
+    super(publicMessage(source, code));
+    this.name = "FatalRetrievalSecurityError";
+    this.source = source;
+    this.code = code;
+  }
+}
+
+function errorRecord(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === "object"
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function codeFromStatus(status: unknown): RetrievalSecurityCode | undefined {
+  if (status === 401) return "UNAUTHORIZED";
+  if (status === 403) return "FORBIDDEN";
+  return undefined;
+}
+
+export function retrievalSecurityCode(
+  value: unknown,
+): RetrievalSecurityCode | undefined {
+  if (value instanceof FatalRetrievalSecurityError) return value.code;
+
+  const record = errorRecord(value);
+  if (record.code === "UNAUTHORIZED" || record.code === "FORBIDDEN") {
+    return record.code;
+  }
+  const details = errorRecord(record.details);
+  return (
+    codeFromStatus(details.upstreamStatus) ??
+    codeFromStatus(record.upstreamStatus) ??
+    codeFromStatus(record.httpStatus) ??
+    codeFromStatus(record.status)
+  );
+}

package/dist/dashboard-runtime/dashboard/src/lib/scope-hierarchy.ts

@@ -0,0 +1,167 @@
+import type { MemoryScope } from "@/types/memory";
+
+export const SCOPE_LEVELS = ["app", "tenant", "agent", "run"] as const;
+
+export type ScopeLevel = (typeof SCOPE_LEVELS)[number];
+export type ScopeGranularity = "all" | ScopeLevel;
+
+export interface ScopeChild {
+  level: ScopeLevel;
+  value: string;
+}
+
+export interface ScopeBreadcrumbItem extends ScopeChild {
+  concrete: boolean;
+}
+
+export const SCOPE_FIELD_BY_LEVEL = {
+  app: "appId",
+  tenant: "tenantId",
+  agent: "agentId",
+  run: "runId",
+} as const satisfies Record<ScopeLevel, keyof MemoryScope>;
+
+const ALL_SCOPE: MemoryScope = {
+  appId: "*",
+  tenantId: "*",
+  agentId: "*",
+  runId: "*",
+};
+
+const LEVEL_BY_FIELD: Record<keyof MemoryScope, ScopeLevel> = {
+  appId: "app",
+  tenantId: "tenant",
+  agentId: "agent",
+  runId: "run",
+};
+
+export function normalizeHierarchicalScope(
+  scope: MemoryScope,
+): MemoryScope | null {
+  const appId = scope.appId?.trim();
+  if (!appId) return null;
+
+  const values = [
+    appId,
+    scope.tenantId?.trim() || "*",
+    scope.agentId?.trim() || "*",
+    scope.runId?.trim() || "*",
+  ];
+  let wildcardSeen = false;
+  const canonical = values.map((value) => {
+    if (wildcardSeen || value === "*") {
+      wildcardSeen = true;
+      return "*";
+    }
+    return value;
+  });
+
+  return {
+    appId: canonical[0],
+    tenantId: canonical[1],
+    agentId: canonical[2],
+    runId: canonical[3],
+  };
+}
+
+export function scopeGranularity(scope: MemoryScope): ScopeGranularity {
+  const canonical = normalizeHierarchicalScope(scope) ?? ALL_SCOPE;
+  if (canonical.appId === "*") return "all";
+  if (canonical.tenantId === "*") return "app";
+  if (canonical.agentId === "*") return "tenant";
+  if (canonical.runId === "*") return "agent";
+  return "run";
+}
+
+export function scopeAtLevel(
+  scope: MemoryScope,
+  level: ScopeGranularity,
+): MemoryScope {
+  if (level === "all") return { ...ALL_SCOPE };
+
+  const canonical = normalizeHierarchicalScope(scope) ?? ALL_SCOPE;
+  const selectedIndex = SCOPE_LEVELS.indexOf(level);
+  const result = { ...ALL_SCOPE };
+  for (let index = 0; index <= selectedIndex; index += 1) {
+    const field = SCOPE_FIELD_BY_LEVEL[SCOPE_LEVELS[index]];
+    const value = canonical[field];
+    if (!value || value === "*") break;
+    result[field] = value;
+  }
+  return result;
+}
+
+export function scopeWithSelection(
+  scope: MemoryScope,
+  field: keyof MemoryScope,
+  value: string,
+): MemoryScope {
+  const canonical = normalizeHierarchicalScope(scope) ?? { ...ALL_SCOPE };
+  const level = LEVEL_BY_FIELD[field];
+  const levelIndex = SCOPE_LEVELS.indexOf(level);
+  canonical[field] = value.trim() || "*";
+  for (let index = levelIndex + 1; index < SCOPE_LEVELS.length; index += 1) {
+    canonical[SCOPE_FIELD_BY_LEVEL[SCOPE_LEVELS[index]]] = "*";
+  }
+  return normalizeHierarchicalScope(canonical) ?? { ...ALL_SCOPE };
+}
+
+export function scopeChildren(
+  scopes: readonly MemoryScope[],
+  parent: MemoryScope,
+): ScopeChild[] {
+  const canonicalParent = normalizeHierarchicalScope(parent) ?? ALL_SCOPE;
+  const parentGranularity = scopeGranularity(canonicalParent);
+  const nextIndex =
+    parentGranularity === "all"
+      ? 0
+      : SCOPE_LEVELS.indexOf(parentGranularity) + 1;
+  if (nextIndex >= SCOPE_LEVELS.length) return [];
+
+  const nextLevel = SCOPE_LEVELS[nextIndex];
+  const nextField = SCOPE_FIELD_BY_LEVEL[nextLevel];
+  const values = new Set<string>();
+
+  for (const scope of scopes) {
+    const candidate = normalizeHierarchicalScope(scope);
+    if (!candidate) continue;
+
+    const matchesParent = SCOPE_LEVELS.slice(0, nextIndex).every((level) => {
+      const field = SCOPE_FIELD_BY_LEVEL[level];
+      return candidate[field] === canonicalParent[field];
+    });
+    const value = candidate[nextField];
+    if (matchesParent && value && value !== "*") values.add(value);
+  }
+
+  return [...values]
+    .sort((left, right) => left.localeCompare(right))
+    .map((value) => ({ level: nextLevel, value }));
+}
+
+export function scopeBreadcrumb(scope: MemoryScope): ScopeBreadcrumbItem[] {
+  const canonical = normalizeHierarchicalScope(scope) ?? ALL_SCOPE;
+  return SCOPE_LEVELS.map((level) => {
+    const value = canonical[SCOPE_FIELD_BY_LEVEL[level]] ?? "*";
+    return { level, value, concrete: value !== "*" };
+  });
+}
+
+export function filterScopeTuples(
+  scopes: readonly MemoryScope[],
+  query: string,
+): MemoryScope[] {
+  const terms = query.toLocaleLowerCase().split(/\s+/).filter(Boolean);
+  if (terms.length === 0) return [...scopes];
+
+  return scopes.filter((scope) => {
+    const canonical = normalizeHierarchicalScope(scope);
+    if (!canonical) return false;
+    const text = SCOPE_LEVELS.map(
+      (level) => canonical[SCOPE_FIELD_BY_LEVEL[level]],
+    )
+      .join(" ")
+      .toLocaleLowerCase();
+    return terms.every((term) => text.includes(term));
+  });
+}