@tablestore/tablestore-agent-cli 0.3.1 → 0.4.1

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/artifacts/route.ts

@@ -0,0 +1,194 @@
+import type { NextRequest } from "next/server";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import { readExactScopeFromQuery } from "../_helpers";
+import { readExactMemoryScope, type AgentWikiScope } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+type ArtifactKind = "skill" | "profile";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+interface PublicArtifact {
+  dreamId: string;
+  actionId: string;
+  kind: ArtifactKind;
+  name: string;
+  description: string;
+  targetScope: {
+    appId: string;
+    tenantId: string;
+    agentId: string;
+    runId: string;
+  };
+  appliedAt?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+function scopeKey(scope: AgentWikiScope): string {
+  return [scope.appId, scope.tenantId, scope.agentId].join("\0");
+}
+
+const ACTION_TYPE: Record<ArtifactKind, "EMIT_SKILL" | "EMIT_PROFILE"> = {
+  skill: "EMIT_SKILL",
+  profile: "EMIT_PROFILE",
+};
+
+function readKind(raw: string | null): ArtifactKind | null {
+  return raw === "skill" || raw === "profile" ? raw : null;
+}
+
+function readLimit(raw: string | null): number | null {
+  if (raw === null) return 100;
+  const value = Number(raw);
+  return Number.isInteger(value) && value >= 1 && value <= 100 ? value : null;
+}
+
+function readRequiredString(
+  value: Record<string, unknown>,
+  key: string,
+): string | null {
+  const raw = value[key];
+  return typeof raw === "string" && raw.length > 0 ? raw : null;
+}
+
+function normalizeArtifact(
+  raw: unknown,
+  kind: ArtifactKind,
+  expectedScope: AgentWikiScope,
+): PublicArtifact | null {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const action = raw as Record<string, unknown>;
+  if (action.action !== ACTION_TYPE[kind] || action.status !== "applied") {
+    return null;
+  }
+  if (
+    !action.newExtract ||
+    typeof action.newExtract !== "object" ||
+    Array.isArray(action.newExtract) ||
+    !action.targetScope ||
+    typeof action.targetScope !== "object" ||
+    Array.isArray(action.targetScope)
+  ) {
+    return null;
+  }
+  const extract = action.newExtract as Record<string, unknown>;
+  const targetScope = readExactMemoryScope(action.targetScope);
+  const dreamId = readRequiredString(action, "dreamId");
+  const actionId = readRequiredString(action, "actionId");
+  const name = readRequiredString(extract, "name");
+  const description = readRequiredString(extract, "description");
+  const createdAt = readRequiredString(action, "createdAt");
+  const updatedAt = readRequiredString(action, "updatedAt");
+  if (
+    extract.kind !== kind ||
+    !dreamId ||
+    !actionId ||
+    !name ||
+    !description ||
+    !targetScope ||
+    scopeKey(targetScope) !== scopeKey(expectedScope) ||
+    !createdAt ||
+    !updatedAt
+  ) {
+    return null;
+  }
+
+  const appliedAt = readRequiredString(action, "appliedAt");
+  return {
+    dreamId,
+    actionId,
+    kind,
+    name,
+    description,
+    targetScope,
+    ...(appliedAt ? { appliedAt } : {}),
+    createdAt,
+    updatedAt,
+  };
+}
+
+function normalizeArtifacts(
+  raw: unknown,
+  kind: ArtifactKind,
+  expectedScope: AgentWikiScope,
+): PublicArtifact[] {
+  if (!Array.isArray(raw)) return [];
+  const artifacts: PublicArtifact[] = [];
+  const seen = new Set<string>();
+  for (const row of raw) {
+    const artifact = normalizeArtifact(row, kind, expectedScope);
+    if (!artifact) continue;
+    const key = `${artifact.dreamId}\0${artifact.actionId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    artifacts.push(artifact);
+  }
+  return artifacts;
+}
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+
+    const params = new URL(request.url).searchParams;
+    const kind = readKind(params.get("kind"));
+    const scope = readExactScopeFromQuery(params);
+    const limit = readLimit(params.get("limit"));
+    if (!kind || !scope || limit === null) {
+      return errorResponse(
+        "BAD_REQUEST",
+        "kind, exact scope, and a limit between 1 and 100 are required",
+        400,
+      );
+    }
+
+    const nextToken = params.get("nextToken") || undefined;
+    const response = await auth.memory.listMemoryDreamActions(
+      {
+        memoryStoreName: store,
+        scope: { ...scope, runId: "*" },
+        actionType: ACTION_TYPE[kind],
+        status: "applied",
+        limit,
+        ...(nextToken ? { nextToken } : {}),
+      },
+      request.signal,
+    );
+    if (response.code !== "SUCCESS") return forwardResponse(response);
+
+    const data =
+      response.data &&
+      typeof response.data === "object" &&
+      !Array.isArray(response.data)
+        ? (response.data as Record<string, unknown>)
+        : {};
+    const upstreamNextToken =
+      typeof data.nextToken === "string" ? data.nextToken : undefined;
+    return forwardResponse({
+      ...response,
+      data: {
+        memoryStoreName: store,
+        artifacts: normalizeArtifacts(data.actions, kind, scope),
+        ...(upstreamNextToken !== undefined
+          ? { nextToken: upstreamNextToken }
+          : {}),
+      },
+    });
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/ingest/route.ts

@@ -0,0 +1,60 @@
+import type { NextRequest } from "next/server";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import {
+  hasCallerWikiId,
+  readOptionalClientToken,
+  readOptionalDreamActionRefs,
+  readWikiJsonBody,
+} from "../_helpers";
+import { toAgentWikiScope } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+export async function POST(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("wiki" in auth)) return auth;
+
+    const body = await readWikiJsonBody(request);
+    const clientToken = readOptionalClientToken(body?.clientToken);
+    const dreamActionRefs = readOptionalDreamActionRefs(body?.dreamActionRefs);
+    if (
+      !body ||
+      hasCallerWikiId(request, body) ||
+      !clientToken.ok ||
+      !dreamActionRefs.ok
+    ) {
+      return errorResponse("BAD_REQUEST", "Invalid ingest Wiki request", 400);
+    }
+
+    const response = await auth.wiki.ingestWiki(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        ...(clientToken.value !== undefined
+          ? { clientToken: clientToken.value }
+          : {}),
+        ...(dreamActionRefs.value !== undefined
+          ? { dreamActionRefs: dreamActionRefs.value }
+          : {}),
+      },
+      request.signal,
+    );
+    return forwardResponse(response);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/page/route.ts

@@ -0,0 +1,55 @@
+import type { NextRequest } from "next/server";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import {
+  hasCallerBuildId,
+  hasCallerWikiId,
+  readExactScopeFromQuery,
+  readWikiPagePath,
+} from "../_helpers";
+import { toAgentWikiScope } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("wiki" in auth)) return auth;
+
+    const params = new URL(request.url).searchParams;
+    const scope = readExactScopeFromQuery(params);
+    const path = readWikiPagePath(params.get("path"));
+    if (
+      hasCallerWikiId(request) ||
+      hasCallerBuildId(request) ||
+      !scope ||
+      !path
+    ) {
+      return errorResponse("BAD_REQUEST", "Invalid Wiki page request", 400);
+    }
+
+    const response = await auth.wiki.getWikiPage(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(scope),
+        path,
+      },
+      request.signal,
+    );
+    return forwardResponse(response);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/pages/route.ts

@@ -0,0 +1,61 @@
+import type { NextRequest } from "next/server";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import {
+  hasCallerBuildId,
+  hasCallerWikiId,
+  readExactScopeFromQuery,
+  readOptionalNextToken,
+  readOptionalQueryLimit,
+} from "../_helpers";
+import { toAgentWikiScope } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("wiki" in auth)) return auth;
+
+    const params = new URL(request.url).searchParams;
+    const scope = readExactScopeFromQuery(params);
+    const limit = readOptionalQueryLimit(params.get("limit"));
+    const nextToken = readOptionalNextToken(params.get("nextToken"));
+    if (
+      hasCallerWikiId(request) ||
+      hasCallerBuildId(request) ||
+      !scope ||
+      !limit.ok ||
+      !nextToken.ok
+    ) {
+      return errorResponse("BAD_REQUEST", "Invalid Wiki pages request", 400);
+    }
+
+    const response = await auth.wiki.listWikiPages(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(scope),
+        ...(limit.value !== undefined ? { limit: limit.value } : {}),
+        ...(nextToken.value !== undefined
+          ? { nextToken: nextToken.value }
+          : {}),
+      },
+      request.signal,
+    );
+    return forwardResponse(response);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/route.ts

@@ -0,0 +1,89 @@
+import type { NextRequest } from "next/server";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import {
+  hasCallerWikiId,
+  readExactScopeFromQuery,
+  readOptionalWikiName,
+  readOptionalWikiSummary,
+  readWikiJsonBody,
+} from "./_helpers";
+import { toAgentWikiScope } from "../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+function invalidRequest(message: string) {
+  return errorResponse("BAD_REQUEST", message, 400);
+}
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("wiki" in auth)) return auth;
+
+    const params = new URL(request.url).searchParams;
+    const scope = readExactScopeFromQuery(params);
+    if (!scope || hasCallerWikiId(request)) {
+      return invalidRequest(
+        "An exact scope without legacy Wiki identity is required",
+      );
+    }
+
+    const response = await auth.wiki.getWiki(
+      { memoryStoreName: store, scope: toAgentWikiScope(scope) },
+      request.signal,
+    );
+    return forwardResponse(response);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+export async function PATCH(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("wiki" in auth)) return auth;
+
+    const body = await readWikiJsonBody(request);
+    if (!body || hasCallerWikiId(request, body)) {
+      return invalidRequest(
+        "An exact scope without legacy Wiki identity is required",
+      );
+    }
+    const name = readOptionalWikiName(body.name);
+    const summary = readOptionalWikiSummary(body.summary);
+    if (
+      !name.ok ||
+      !summary.ok ||
+      (name.value === undefined && summary.value === undefined)
+    ) {
+      return invalidRequest("Update requires a valid name or summary");
+    }
+
+    const response = await auth.wiki.updateWiki(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        ...(name.value !== undefined ? { name: name.value } : {}),
+        ...(summary.value !== undefined ? { summary: summary.value } : {}),
+      },
+      request.signal,
+    );
+    return forwardResponse(response);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/search/route.ts

@@ -0,0 +1,58 @@
+import type { NextRequest } from "next/server";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import {
+  hasCallerBuildId,
+  hasCallerWikiId,
+  readOptionalJsonLimit,
+  readRequiredSearchQuery,
+  readWikiJsonBody,
+} from "../_helpers";
+import { toAgentWikiScope } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+export async function POST(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("wiki" in auth)) return auth;
+
+    const body = await readWikiJsonBody(request);
+    const query = readRequiredSearchQuery(body?.query);
+    const limit = readOptionalJsonLimit(body?.limit);
+    if (
+      !body ||
+      hasCallerWikiId(request, body) ||
+      hasCallerBuildId(request, body) ||
+      !query ||
+      !limit.ok
+    ) {
+      return errorResponse("BAD_REQUEST", "Invalid Wiki search request", 400);
+    }
+
+    const response = await auth.wiki.searchWikiPages(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        query,
+        ...(limit.value !== undefined ? { limit: limit.value } : {}),
+      },
+      request.signal,
+    );
+    return forwardResponse(response);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}