nolo-cli 0.1.13 → 0.1.15

package/ai/tools/table/rowTools.ts

@@ -0,0 +1,366 @@
+import type { RootState } from "app/store";
+import {
+  applyRowFilters,
+  formatKnownColumns,
+  normalizeRowValues,
+  pickRowColumns,
+  sortRows,
+  type RowFilters,
+} from "render/table/toolValueUtils";
+import { buildNewRow, ensureRowsLoaded, loadTableMetaOrThrow, patchRecord, resolveRowOrThrow, resolveTableIdentity, writeRow } from "./toolShared";
+
+const toPreviewJson = (value: unknown, maxLength = 600): string => {
+  try {
+    const json = JSON.stringify(value, null, 2);
+    if (json.length <= maxLength) return json;
+    return `${json.slice(0, maxLength)}\n…(已截断)…`;
+  } catch {
+    return "[无法序列化为 JSON]";
+  }
+};
+
+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 };
+};
+
+export const queryTableRowsFunctionSchema = {
+  name: "queryTableRows",
+  description: "查询指定表中的行，支持简单字段过滤、排序、分页和返回指定列。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string", description: "租户 ID。聊天场景中必须显式传入。" },
+      tableId: { type: "string", description: "表 ID。聊天场景中必须显式传入。" },
+      filters: {
+        type: "object",
+        description: "按列名做精确匹配过滤，例如 {\"status\":\"todo\"}。",
+      },
+      columns: {
+        type: "array",
+        items: { type: "string" },
+        description: "可选：只返回这些列。",
+      },
+      limit: { type: "number", description: "最多返回多少行，默认 20，最大 200。" },
+      offset: { type: "number", description: "从第几行开始返回，默认 0。" },
+      sortBy: { type: "string", description: "排序字段，默认 updatedAt。" },
+      sortOrder: {
+        type: "string",
+        enum: ["asc", "desc"],
+        description: "排序方向，默认 desc。",
+      },
+    },
+  },
+};
+
+export async function queryTableRowsFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const rows = await ensureRowsLoaded(thunkApi, tenantId, tableId);
+  const filters = (args?.filters ?? {}) as RowFilters;
+  const limit = Math.min(Math.max(Number(args?.limit ?? 20), 1), 200);
+  const offset = Math.max(Number(args?.offset ?? 0), 0);
+  const sortBy = typeof args?.sortBy === "string" && args.sortBy.trim() ? args.sortBy.trim() : "updatedAt";
+  const sortOrder = args?.sortOrder === "asc" ? "asc" : "desc";
+  const columns = Array.isArray(args?.columns)
+    ? args.columns.filter((value: unknown): value is string => typeof value === "string" && value.trim().length > 0)
+    : undefined;
+
+  const filtered = applyRowFilters(rows, filters);
+  const sorted = sortRows(filtered, sortBy, sortOrder);
+  const page = sorted.slice(offset, offset + limit);
+  const items = columns ? page.map((row) => pickRowColumns(row, columns)) : page;
+
+  return {
+    rawData: {
+      tenantId,
+      tableId,
+      total: filtered.length,
+      limit,
+      offset,
+      items,
+    },
+    displayData:
+      `在表「${tableMeta.displayName || tableId}」中查询到 ${filtered.length} 行，当前返回 ${items.length} 行。\n` +
+      `字段：${formatKnownColumns(tableMeta)}\n\n` +
+      `${toPreviewJson(items)}`,
+  };
+}
+
+export const updateTableRowFunctionSchema = {
+  name: "updateTableRow",
+  description: "按 rowId 或 dbKey 更新指定表中的一行数据，只修改 changes 中提供的字段。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      rowId: { type: "string", description: "要更新的行 ID。" },
+      dbKey: { type: "string", description: "要更新的行 dbKey。rowId 与 dbKey 二选一即可。" },
+      changes: {
+        type: "object",
+        description: "要修改的字段集合，例如 {\"status\":\"done\"}。",
+      },
+    },
+    required: ["changes"],
+  },
+};
+
+export async function updateTableRowFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const targetRow = await resolveRowOrThrow(thunkApi, { tenantId, tableId, rowId: args?.rowId, dbKey: args?.dbKey });
+  const changes = args?.changes;
+
+  if (!changes || typeof changes !== "object" || Array.isArray(changes)) {
+    throw new Error("updateTableRow.changes 必须是对象。");
+  }
+
+  const normalized = normalizeRowValues(tableMeta.columns, changes, { mode: "update" });
+  if (normalized.errors.length > 0) {
+    throw new Error(normalized.errors.join("\n"));
+  }
+  if (Object.keys(normalized.sanitizedValues).length === 0) {
+    throw new Error(
+      `updateTableRow 没有可更新的有效字段。已知字段：${formatKnownColumns(tableMeta)}`
+    );
+  }
+
+  const updatedAt = new Date().toISOString();
+  const updated = await patchRecord(thunkApi, targetRow.dbKey, {
+    ...normalized.sanitizedValues,
+    updatedAt,
+  });
+
+  const ignoredInfo =
+    normalized.ignoredColumns.length > 0
+      ? `\n\n注意：以下字段已忽略：${normalized.ignoredColumns.join(", ")}`
+      : "";
+
+  return {
+    rawData: updated,
+    displayData:
+      `已更新表「${tableMeta.displayName || tableId}」中的行 ${targetRow.rowId}。${ignoredInfo}\n\n` +
+      `${toPreviewJson(updated)}`,
+  };
+}
+
+export const deleteTableRowFunctionSchema = {
+  name: "deleteTableRow",
+  description: "删除指定表中的一行数据（软删除）。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      rowId: { type: "string" },
+      dbKey: { type: "string" },
+    },
+  },
+};
+
+export async function deleteTableRowFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const targetRow = await resolveRowOrThrow(thunkApi, { tenantId, tableId, rowId: args?.rowId, dbKey: args?.dbKey });
+  const updatedAt = new Date().toISOString();
+  const deleted = await patchRecord(thunkApi, targetRow.dbKey, {
+    deletedAt: updatedAt,
+    updatedAt,
+  });
+
+  return {
+    rawData: deleted,
+    displayData: `已从表「${tableMeta.displayName || tableId}」中删除行 ${targetRow.rowId}。`,
+  };
+}
+
+export const addTableRowsFunctionSchema = {
+  name: "addTableRows",
+  description: "批量向指定表中新增多行数据。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      rows: {
+        type: "array",
+        items: { type: "object" },
+        description: "每一项都是一行数据对象，key 必须是表中的列名。",
+      },
+    },
+    required: ["rows"],
+  },
+};
+
+export async function addTableRowsFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const rows = Array.isArray(args?.rows) ? args.rows : [];
+  if (rows.length === 0) {
+    throw new Error("addTableRows.rows 至少需要包含一行。");
+  }
+
+  const createdRows: any[] = [];
+  const ignoredColumns = new Set<string>();
+  for (const row of rows) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) {
+      throw new Error("addTableRows.rows 中的每一项都必须是对象。");
+    }
+    const normalized = normalizeRowValues(tableMeta.columns, row, { mode: "create" });
+    if (normalized.errors.length > 0) {
+      throw new Error(normalized.errors.join("\n"));
+    }
+    if (Object.keys(normalized.sanitizedValues).length === 0) {
+      throw new Error(`存在一行没有任何有效字段。已知字段：${formatKnownColumns(tableMeta)}`);
+    }
+    normalized.ignoredColumns.forEach((column) => ignoredColumns.add(column));
+    const created = buildNewRow(tenantId, tableId, normalized.sanitizedValues);
+    await writeRow(thunkApi, created);
+    createdRows.push(created);
+  }
+
+  const ignoredInfo =
+    ignoredColumns.size > 0 ? `\n\n注意：以下字段已忽略：${Array.from(ignoredColumns).join(", ")}` : "";
+
+  return {
+    rawData: {
+      count: createdRows.length,
+      items: createdRows,
+    },
+    displayData:
+      `已向表「${tableMeta.displayName || tableId}」批量新增 ${createdRows.length} 行。${ignoredInfo}\n\n` +
+      `${toPreviewJson(createdRows.slice(0, 10))}`,
+  };
+}
+
+export const updateTableRowsFunctionSchema = {
+  name: "updateTableRows",
+  description: "批量更新多行数据。每项都需要 rowId 或 dbKey，以及 changes。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      updates: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            rowId: { type: "string" },
+            dbKey: { type: "string" },
+            changes: { type: "object" },
+          },
+        },
+      },
+    },
+    required: ["updates"],
+  },
+};
+
+export async function updateTableRowsFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const updates = Array.isArray(args?.updates) ? args.updates : [];
+  if (updates.length === 0) {
+    throw new Error("updateTableRows.updates 至少需要包含一项。");
+  }
+
+  const results: any[] = [];
+  const ignoredColumns = new Set<string>();
+  for (const item of updates) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      throw new Error("updateTableRows.updates 中的每一项都必须是对象。");
+    }
+    const targetRow = await resolveRowOrThrow(thunkApi, {
+      tenantId,
+      tableId,
+      rowId: item.rowId,
+      dbKey: item.dbKey,
+    });
+    const normalized = normalizeRowValues(tableMeta.columns, item.changes ?? {}, { mode: "update" });
+    if (normalized.errors.length > 0) {
+      throw new Error(normalized.errors.join("\n"));
+    }
+    if (Object.keys(normalized.sanitizedValues).length === 0) {
+      throw new Error(`行 ${targetRow.rowId} 没有可更新的有效字段。`);
+    }
+    normalized.ignoredColumns.forEach((column) => ignoredColumns.add(column));
+    const updated = await patchRecord(thunkApi, targetRow.dbKey, {
+      ...normalized.sanitizedValues,
+      updatedAt: new Date().toISOString(),
+    });
+    results.push(updated);
+  }
+
+  const ignoredInfo =
+    ignoredColumns.size > 0 ? `\n\n注意：以下字段已忽略：${Array.from(ignoredColumns).join(", ")}` : "";
+
+  return {
+    rawData: {
+      count: results.length,
+      items: results,
+    },
+    displayData:
+      `已批量更新表「${tableMeta.displayName || tableId}」中的 ${results.length} 行。${ignoredInfo}`,
+  };
+}
+
+export const deleteTableRowsFunctionSchema = {
+  name: "deleteTableRows",
+  description: "批量删除多行数据（软删除）。",
+  parameters: {
+    type: "object",
+    properties: {
+      tenantId: { type: "string" },
+      tableId: { type: "string" },
+      rowIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "要删除的 rowId 列表。",
+      },
+      dbKeys: {
+        type: "array",
+        items: { type: "string" },
+        description: "要删除的 dbKey 列表。",
+      },
+    },
+  },
+};
+
+export async function deleteTableRowsFunc(args: any, thunkApi: any) {
+  const { tenantId, tableId } = requireTableIdentity(args, thunkApi);
+  const tableMeta = await loadTableMetaOrThrow(thunkApi, tenantId, tableId);
+  const rowIds = Array.isArray(args?.rowIds) ? args.rowIds : [];
+  const dbKeys = Array.isArray(args?.dbKeys) ? args.dbKeys : [];
+  const targets = [
+    ...rowIds.map((rowId: string) => ({ rowId })),
+    ...dbKeys.map((dbKey: string) => ({ dbKey })),
+  ];
+
+  if (targets.length === 0) {
+    throw new Error("deleteTableRows 需要至少提供一个 rowId 或 dbKey。");
+  }
+
+  const results = [];
+  for (const target of targets) {
+    const row = await resolveRowOrThrow(thunkApi, { tenantId, tableId, rowId: target.rowId, dbKey: target.dbKey });
+    const deleted = await patchRecord(thunkApi, row.dbKey, {
+      deletedAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+    results.push(deleted);
+  }
+
+  return {
+    rawData: {
+      count: results.length,
+      items: results,
+    },
+    displayData: `已从表「${tableMeta.displayName || tableId}」中批量删除 ${results.length} 行。`,
+  };
+}

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}」。`,
+  };
+}