nolo-cli 0.1.39 → 0.1.41

package/ai/tools/table/schemaTools.ts

@@ -0,0 +1,244 @@
+import { patchRecord, loadTableMetaOrThrow, ensureRowsLoaded, resolveTableIdentity } from "./toolShared";
+import type { RootState } from "../../../app/store";
+import type { TableColumn } from "../../../render/table/types";
+import { ulid } from "../../../database/utils/ulid";
+
+const requireTableIdentity = (args: { tenantId?: string; tableId?: string }, thunkApi: any) => {
+  const state = thunkApi.getState() as RootState;
+  const { tenantId, tableId } = resolveTableIdentity(args, state);
+  if (!tenantId || !tableId) {
+    throw new Error("需要显式提供 tenantId 和 tableId，或在已打开的表页面中调用。");
+  }
+  return { tenantId, tableId };
+};
+
+const ensureColumnName = (name: unknown): string => {
+  if (typeof name !== "string" || !name.trim()) {
+    throw new Error("列名不能为空。");
+  }
+  return name.trim();
+};
+
+const normalizeOptions = (options: unknown): string[] | undefined => {
+  if (!Array.isArray(options)) return undefined;
+  const normalized = options
+    .map((value) => (typeof value === "string" ? value.trim() : ""))
+    .filter(Boolean);
+  return normalized.length > 0 ? normalized : undefined;
+};
+
+export const addTableColumnFunctionSchema = {
+  name: "addTableColumn",
+  description: "向指定表中新增一列。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      name: { type: "string" },
+      label: { type: "string" },
+      type: {
+        type: "string",
+        enum: ["text", "number", "boolean", "date", "datetime", "select", "multi_select"],
+      },
+      description: { type: "string" },
+      required: { type: "boolean" },
+      options: { type: "array", items: { type: "string" } },
+    },
+    required: ["name"],
+  },
+};
+
+export async function addTableColumnFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const name = ensureColumnName(args?.name);
+  if (tableMeta.columns.some((column) => column.name === name)) {
+    throw new Error(`字段 ${name} 已存在。`);
+  }
+
+  const column: TableColumn = {
+    id: ulid(),
+    name,
+    label: typeof args?.label === "string" && args.label.trim() ? args.label.trim() : name,
+    type: typeof args?.type === "string" ? args.type : "text",
+    description: typeof args?.description === "string" && args.description.trim() ? args.description.trim() : undefined,
+    required: typeof args?.required === "boolean" ? args.required : undefined,
+    options: normalizeOptions(args?.options),
+  };
+
+  const updatedAt = new Date().toISOString();
+  const updated = await patchRecord(thunkApi, tableMeta.dbKey, {
+    columns: [...tableMeta.columns, column],
+    updatedAt,
+  });
+
+  return {
+    rawData: updated,
+    displayData: `已向表「${tableMeta.displayName || tableId}」新增字段 ${name}。`,
+  };
+}
+
+export const deleteTableColumnFunctionSchema = {
+  name: "deleteTableColumn",
+  description: "删除指定表中的某一列，并同步从已有行中移除该字段。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      columnName: { type: "string" },
+    },
+    required: ["columnName"],
+  },
+};
+
+export async function deleteTableColumnFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const columnName = ensureColumnName(args?.columnName);
+  if (!tableMeta.columns.some((column) => column.name === columnName)) {
+    throw new Error(`字段 ${columnName} 不存在。`);
+  }
+
+  const rows = await ensureRowsLoaded(thunkApi, tenantId, tableId);
+  const updatedAt = new Date().toISOString();
+  for (const row of rows) {
+    if (Object.prototype.hasOwnProperty.call(row, columnName)) {
+      await patchRecord(thunkApi, row.dbKey, {
+        [columnName]: null,
+        updatedAt,
+      });
+    }
+  }
+
+  const updated = await patchRecord(thunkApi, tableMeta.dbKey, {
+    columns: tableMeta.columns.filter((column) => column.name !== columnName),
+    updatedAt,
+  });
+
+  return {
+    rawData: updated,
+    displayData: `已从表「${tableMeta.displayName || tableId}」删除字段 ${columnName}。`,
+  };
+}
+
+export const renameTableColumnFunctionSchema = {
+  name: "renameTableColumn",
+  description: "修改表字段的 machine name，并同步迁移所有已有行的数据 key。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      oldName: { type: "string" },
+      newName: { type: "string" },
+    },
+    required: ["oldName", "newName"],
+  },
+};
+
+export async function renameTableColumnFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const oldName = ensureColumnName(args?.oldName);
+  const newName = ensureColumnName(args?.newName);
+
+  if (!tableMeta.columns.some((column) => column.name === oldName)) {
+    throw new Error(`字段 ${oldName} 不存在。`);
+  }
+  if (tableMeta.columns.some((column) => column.name === newName)) {
+    throw new Error(`字段 ${newName} 已存在。`);
+  }
+
+  const rows = await ensureRowsLoaded(thunkApi, tenantId, tableId);
+  const updatedAt = new Date().toISOString();
+  for (const row of rows) {
+    if (Object.prototype.hasOwnProperty.call(row, oldName)) {
+      await patchRecord(thunkApi, row.dbKey, {
+        [newName]: row[oldName],
+        [oldName]: null,
+        updatedAt,
+      });
+    }
+  }
+
+  const updated = await patchRecord(thunkApi, tableMeta.dbKey, {
+    columns: tableMeta.columns.map((column) =>
+      column.name === oldName ? { ...column, name: newName } : column
+    ),
+    updatedAt,
+  });
+
+  return {
+    rawData: updated,
+    displayData: `已将表「${tableMeta.displayName || tableId}」中的字段 ${oldName} 重命名为 ${newName}。`,
+  };
+}
+
+export const renameTableColumnLabelFunctionSchema = {
+  name: "renameTableColumnLabel",
+  description: "修改表字段的显示名，不改变行数据里的 key。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      columnName: { type: "string" },
+      newLabel: { type: "string" },
+    },
+    required: ["columnName", "newLabel"],
+  },
+};
+
+export async function renameTableColumnLabelFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const columnName = ensureColumnName(args?.columnName);
+  const newLabel = ensureColumnName(args?.newLabel);
+
+  if (!tableMeta.columns.some((column) => column.name === columnName)) {
+    throw new Error(`字段 ${columnName} 不存在。`);
+  }
+
+  const updated = await patchRecord(thunkApi, tableMeta.dbKey, {
+    columns: tableMeta.columns.map((column) =>
+      column.name === columnName ? { ...column, label: newLabel } : column
+    ),
+    updatedAt: new Date().toISOString(),
+  });
+
+  return {
+    rawData: updated,
+    displayData: `已将字段 ${columnName} 的显示名更新为 ${newLabel}。`,
+  };
+}
+
+export const renameTableFunctionSchema = {
+  name: "renameTable",
+  description: "更新表的显示名称。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      newName: { type: "string" },
+    },
+    required: ["newName"],
+  },
+};
+
+export async function renameTableFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const newName = ensureColumnName(args?.newName);
+  const updated = await patchRecord(thunkApi, tableMeta.dbKey, {
+    displayName: newName,
+    updatedAt: new Date().toISOString(),
+  });
+
+  return {
+    rawData: updated,
+    displayData: `已将表名更新为「${newName}」。`,
+  };
+}

package/ai/tools/table/shareTableTool.ts

@@ -0,0 +1,148 @@
+import { DataType } from "../../../create/types";
+import { readAndWait } from "../../../database/dbSlice";
+import { shareResourceAction } from "../../../share/action";
+import { hasExplicitPublicShareRequest } from "../../../share/publicSharePolicy";
+import { selectAllMsgs, selectCurrentDialogId } from "../../../chat/messages/messageSlice";
+
+type ShareTableArgs = {
+  dbKey?: string;
+  tenantId?: string;
+  tableId?: string;
+  title?: string;
+  description?: string;
+  visibility?: "private" | "community";
+};
+
+type ShareTableResult = {
+  rawData: {
+    token: string;
+    key: string;
+    url: string;
+  };
+  displayData: string;
+};
+
+export const shareTableFunctionSchema = {
+  name: "shareTable",
+  description:
+    "把一张表发布为分享链接。默认用于社区分享；只有当用户明确要求公开/社区分享时才应调用。",
+  parameters: {
+    type: "object",
+    properties: {
+      dbKey: {
+        type: "string",
+        description: "表 meta 记录的 dbKey，例如 meta-user123-table123。",
+      },
+      tenantId: {
+        type: "string",
+        description: "表所属租户 ID。dbKey 缺失时必填。",
+      },
+      tableId: {
+        type: "string",
+        description: "表 ID。dbKey 缺失时必填。",
+      },
+      title: {
+        type: "string",
+        description: "分享标题；不传则回退为表 ID。",
+      },
+      description: {
+        type: "string",
+        description: "可选：分享描述。",
+      },
+      visibility: {
+        type: "string",
+        enum: ["private", "community"],
+        description: "默认 community。",
+      },
+    },
+  },
+};
+
+const resolveTableDbKey = (args: ShareTableArgs): string => {
+  if (typeof args.dbKey === "string" && args.dbKey.trim()) {
+    return args.dbKey.trim();
+  }
+  if (
+    typeof args.tenantId === "string" &&
+    args.tenantId.trim() &&
+    typeof args.tableId === "string" &&
+    args.tableId.trim()
+  ) {
+    return `meta-${args.tenantId.trim()}-${args.tableId.trim()}`;
+  }
+  throw new Error("shareTable 需要提供 dbKey，或同时提供 tenantId 和 tableId。");
+};
+
+const asNonEmptyString = (value: unknown): string =>
+  typeof value === "string" && value.trim() ? value.trim() : "";
+
+const readSharedTableMeta = async (
+  thunkApi: any,
+  tableDbKey: string
+): Promise<Record<string, unknown> | null> => {
+  if (typeof thunkApi?.dispatch !== "function") return null;
+  const result = await thunkApi.dispatch(readAndWait(tableDbKey));
+  if (!readAndWait.fulfilled.match(result) || !result.payload || typeof result.payload !== "object") {
+    return null;
+  }
+  return result.payload as Record<string, unknown>;
+};
+
+export async function shareTableFunc(
+  args: ShareTableArgs,
+  thunkApi: any
+): Promise<ShareTableResult> {
+  const state = thunkApi?.getState?.();
+  const dialogId = state ? selectCurrentDialogId(state) : undefined;
+  const latestUserInput = state
+    ? selectAllMsgs(state, dialogId)
+        .slice()
+        .reverse()
+        .find((message) => message?.role === "user" && typeof message?.content === "string")
+        ?.content
+    : undefined;
+  if (!hasExplicitPublicShareRequest(latestUserInput)) {
+    throw new Error("当前策略不允许在用户未明确要求公开/社区分享时自动发布表。");
+  }
+
+  const tableDbKey = resolveTableDbKey(args);
+  const tableMeta =
+    !asNonEmptyString(args.tenantId) || !asNonEmptyString(args.tableId) || !asNonEmptyString(args.title)
+      ? await readSharedTableMeta(thunkApi, tableDbKey)
+      : null;
+  const tenantId = asNonEmptyString(args.tenantId) || asNonEmptyString(tableMeta?.tenantId);
+  const tableId = asNonEmptyString(args.tableId) || asNonEmptyString(tableMeta?.tableId);
+  const title =
+    asNonEmptyString(args.title) ||
+    asNonEmptyString(tableMeta?.displayName) ||
+    asNonEmptyString(tableMeta?.title) ||
+    tableId ||
+    tableDbKey;
+
+  const result = await shareResourceAction(
+    {
+      type: DataType.TABLE,
+      data: {
+        dbKey: tableDbKey,
+        ...(tenantId ? { tenantId } : {}),
+        ...(tableId ? { tableId } : {}),
+        displayName: title,
+      },
+      title,
+      description:
+        typeof args.description === "string" && args.description.trim()
+          ? args.description.trim()
+          : undefined,
+      visibility: args.visibility ?? "community",
+    },
+    thunkApi
+  );
+
+  return {
+    rawData: {
+      ...result,
+      url: `/share/${result.token}`,
+    },
+    displayData: `表已分享：/share/${result.token}`,
+  };
+}

package/ai/tools/table/toolShared.ts

@@ -0,0 +1,129 @@
+import type { RootState } from "../../../app/store";
+import { readAndWait, patch, write } from "../../../database/dbSlice";
+import { metaKey, rowKey } from "../../../database/keys";
+import { DataType } from "../../../create/types";
+import { loadTableRows } from "../../../render/table/tableSlice";
+import type { TableMeta } from "../../../render/table/types";
+
+export const resolveTableIdentity = (
+  args: { tenantId?: string; tableId?: string },
+  state: RootState
+) => {
+  const currentTable = state.table.currentTable;
+  const tenantId = args.tenantId ?? currentTable?.tenantId;
+  const tableId = args.tableId ?? currentTable?.tableId;
+  return { tenantId, tableId, currentTable };
+};
+
+export async function loadTableMetaOrThrow(
+  thunkApi: any,
+  tenantId: string,
+  tableId: string
+): Promise<TableMeta> {
+  const result = await thunkApi.dispatch(readAndWait(metaKey(tenantId, tableId)));
+  if (!readAndWait.fulfilled.match(result) || !result.payload) {
+    const message =
+      (result.payload as any)?.message ||
+      result.error?.message ||
+      `找不到表 ${tableId} 的定义。`;
+    throw new Error(message);
+  }
+  return result.payload as TableMeta;
+}
+
+export async function ensureRowsLoaded(
+  thunkApi: any,
+  tenantId: string,
+  tableId: string
+): Promise<any[]> {
+  const result = await thunkApi.dispatch(loadTableRows({ tenantId, tableId }));
+  if (!loadTableRows.fulfilled.match(result)) {
+    const message =
+      (result.payload as any) ||
+      result.error?.message ||
+      "加载表行失败";
+    throw new Error(message);
+  }
+
+  const state = thunkApi.getState() as RootState;
+  return state.table.rows.filter(
+    (row: any) => row?.tenantId === tenantId && row?.tableId === tableId && !row?.deletedAt
+  );
+}
+
+export async function resolveRowOrThrow(
+  thunkApi: any,
+  args: { tenantId: string; tableId: string; rowId?: string; dbKey?: string }
+) {
+  const { tenantId, tableId, rowId, dbKey } = args;
+
+  if (!rowId && !dbKey) {
+    throw new Error("需要提供 rowId 或 dbKey 才能定位表行。");
+  }
+
+  const finalDbKey = dbKey || rowKey.single(tenantId, tableId, String(rowId));
+  const readResult = await thunkApi.dispatch(readAndWait(finalDbKey));
+  if (readAndWait.fulfilled.match(readResult) && readResult.payload && !readResult.payload.deletedAt) {
+    return readResult.payload;
+  }
+
+  const rows = await ensureRowsLoaded(thunkApi, tenantId, tableId);
+  const found = rows.find((row) => row?.dbKey === finalDbKey || row?.rowId === rowId);
+  if (!found) {
+    throw new Error(`找不到要操作的行：${rowId || finalDbKey}`);
+  }
+  return found;
+}
+
+export async function writeRow(thunkApi: any, row: any) {
+  const result = await thunkApi.dispatch(
+    write({
+      data: row,
+      customKey: row.dbKey,
+    })
+  );
+  if (!write.fulfilled.match(result)) {
+    const message =
+      (result.payload as any)?.message ||
+      result.error?.message ||
+      "写入表行失败";
+    throw new Error(message);
+  }
+  return result.payload;
+}
+
+export async function patchRecord(thunkApi: any, dbKey: string, changes: Record<string, any>) {
+  const result = await thunkApi.dispatch(
+    patch({
+      dbKey,
+      changes,
+    })
+  );
+  if (!patch.fulfilled.match(result)) {
+    const message =
+      (result.payload as any)?.message ||
+      result.error?.message ||
+      `更新记录失败：${dbKey}`;
+    throw new Error(message);
+  }
+  return result.payload;
+}
+
+export function buildNewRow(
+  tenantId: string,
+  tableId: string,
+  values: Record<string, any>
+) {
+  const { dbKey, rowId } = rowKey.create(tenantId, tableId);
+  const now = new Date().toISOString();
+  return {
+    dbKey,
+    tenantId,
+    tableId,
+    rowId,
+    createdAt: now,
+    updatedAt: now,
+    type: DataType.TABLE_ROW as const,
+    ...values,
+  };
+}

package/ai/tools/taobaoTmallProductScraperTool.ts

@@ -0,0 +1,49 @@
+import { callApifyActor } from "./apifyActorClient";
+
+export const taobaoTmallProductScraperFunctionSchema = {
+  name: "taobaoTmallProductScraper",
+  description:
+    "使用 Apify Taobao/Tmall Product Scraper 获取淘宝/天猫商品真实详情，返回标题、价格、SKU、库存、图片、店铺、属性和规格参数。适合用户提供淘宝/天猫链接或商品 ID 后做真实参数对比。",
+  parameters: {
+    type: "object",
+    properties: {
+      itemId: {
+        type: "string",
+        description:
+          "淘宝/天猫数字商品 ID。可从链接中的 id 参数提取，例如 https://item.taobao.com/item.htm?id=744983869996。",
+      },
+      detailDepth: {
+        type: "string",
+        enum: ["lite", "standard", "full"],
+        description:
+          "详情深度。full 会尽量返回优惠后价格、属性、规格、SKU 和促销信息；默认 full。",
+        default: "full",
+      },
+    },
+    required: ["itemId"],
+  },
+};
+
+export async function taobaoTmallProductScraperFunc(
+  args: {
+    itemId: string;
+    detailDepth?: "lite" | "standard" | "full";
+  },
+  thunkApi: any
+) {
+  const itemId = String(args.itemId ?? "").trim();
+  if (!/^\d{6,}$/.test(itemId)) {
+    throw new Error("淘宝/天猫商品详情抓取失败：itemId 必须是有效的数字商品 ID。");
+  }
+
+  return callApifyActor(thunkApi, {
+    actorId: "sian.agency~taobao-tmall-product-scraper",
+    input: {
+      operation: "productDetail",
+      itemId,
+      detailDepth: args.detailDepth ?? "full",
+    },
+    resultType: "datasetItems",
+    displayName: "Taobao/Tmall Product Scraper",
+  });
+}