nolo-cli 0.1.40 → 0.1.41

package/render/table/toolValueUtils.ts

@@ -0,0 +1,363 @@
+import type { TableColumn, TableMeta } from "./types";
+
+const RESERVED_ROW_KEYS = new Set([
+  "dbKey",
+  "tenantId",
+  "tableId",
+  "rowId",
+  "createdAt",
+  "updatedAt",
+  "deletedAt",
+  "type",
+]);
+
+export type RowFilterValue =
+  | string
+  | number
+  | boolean
+  | null
+  | string[]
+  | number[]
+  | boolean[];
+
+export type RowFilters = Record<string, RowFilterValue>;
+
+export type NormalizeRowOptions = {
+  mode?: "create" | "update";
+};
+
+export type NormalizeRowResult = {
+  sanitizedValues: Record<string, any>;
+  ignoredColumns: string[];
+  errors: string[];
+};
+
+const hasOwn = (value: unknown, key: string): boolean =>
+  !!value && typeof value === "object" && !Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, key);
+
+export const getRowValueByPath = (row: any, key: string): { exists: boolean; value: any } => {
+  if (!key) return { exists: false, value: undefined };
+  if (hasOwn(row, key)) {
+    return { exists: true, value: row[key] };
+  }
+  if (!key.includes(".")) {
+    return { exists: false, value: undefined };
+  }
+
+  let current = row;
+  for (const part of key.split(".")) {
+    if (!part || !hasOwn(current, part)) {
+      return { exists: false, value: undefined };
+    }
+    current = current[part];
+  }
+  return { exists: true, value: current };
+};
+
+const setValueByPath = (target: Record<string, any>, key: string, value: any) => {
+  if (!key.includes(".")) {
+    target[key] = value;
+    return;
+  }
+  const parts = key.split(".").filter(Boolean);
+  if (!parts.length) return;
+  let current = target;
+  for (const part of parts.slice(0, -1)) {
+    if (!current[part] || typeof current[part] !== "object" || Array.isArray(current[part])) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+};
+
+const isBlank = (value: unknown): boolean =>
+  value === undefined ||
+  value === null ||
+  (typeof value === "string" && value.trim() === "");
+
+const normalizeBoolean = (value: unknown): boolean | undefined => {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (value === 1) return true;
+    if (value === 0) return false;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "1", "yes", "y"].includes(normalized)) return true;
+    if (["false", "0", "no", "n"].includes(normalized)) return false;
+  }
+  return undefined;
+};
+
+const normalizeDate = (value: unknown): string | undefined => {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString().slice(0, 10);
+  }
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) return trimmed;
+  const parsed = new Date(trimmed);
+  if (Number.isNaN(parsed.getTime())) return undefined;
+  return parsed.toISOString().slice(0, 10);
+};
+
+const normalizeDateTime = (value: unknown): string | undefined => {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString();
+  }
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  const parsed = new Date(trimmed);
+  if (Number.isNaN(parsed.getTime())) return undefined;
+  return parsed.toISOString();
+};
+
+const normalizeMultiSelectInput = (value: unknown): string[] | undefined => {
+  if (Array.isArray(value)) {
+    const list = value
+      .map((item) =>
+        typeof item === "string" || typeof item === "number" || typeof item === "boolean"
+          ? String(item).trim()
+          : ""
+      )
+      .filter(Boolean);
+    return list;
+  }
+
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return [];
+    return trimmed
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean);
+  }
+
+  return undefined;
+};
+
+const normalizeSingleValue = (
+  column: TableColumn,
+  rawValue: unknown
+): { value?: any; error?: string } => {
+  if (rawValue === undefined) {
+    return { value: undefined };
+  }
+
+  if (rawValue === null) {
+    if (column.required) {
+      return { error: `字段 ${column.name} 是必填项，不能设为 null。` };
+    }
+    return { value: null };
+  }
+
+  switch (column.type ?? "text") {
+    case "number": {
+      if (typeof rawValue === "number" && Number.isFinite(rawValue)) {
+        return { value: rawValue };
+      }
+      if (typeof rawValue === "string" && rawValue.trim()) {
+        const parsed = Number(rawValue);
+        if (Number.isFinite(parsed)) {
+          return { value: parsed };
+        }
+      }
+      return { error: `字段 ${column.name} 需要 number 值。` };
+    }
+    case "boolean": {
+      const normalized = normalizeBoolean(rawValue);
+      if (normalized === undefined) {
+        return { error: `字段 ${column.name} 需要 boolean 值。` };
+      }
+      return { value: normalized };
+    }
+    case "date": {
+      const normalized = normalizeDate(rawValue);
+      if (!normalized) {
+        return { error: `字段 ${column.name} 需要日期字符串（YYYY-MM-DD）。` };
+      }
+      return { value: normalized };
+    }
+    case "datetime": {
+      const normalized = normalizeDateTime(rawValue);
+      if (!normalized) {
+        return { error: `字段 ${column.name} 需要可解析的日期时间字符串。` };
+      }
+      return { value: normalized };
+    }
+    case "select": {
+      const normalized =
+        typeof rawValue === "string" || typeof rawValue === "number" || typeof rawValue === "boolean"
+          ? String(rawValue).trim()
+          : "";
+      if (!normalized) {
+        return { error: `字段 ${column.name} 需要非空字符串。` };
+      }
+      if (Array.isArray(column.options) && column.options.length > 0 && !column.options.includes(normalized)) {
+        return {
+          error: `字段 ${column.name} 只能是以下值之一：${column.options.join(", ")}。`,
+        };
+      }
+      return { value: normalized };
+    }
+    case "multi_select": {
+      const normalized = normalizeMultiSelectInput(rawValue);
+      if (!normalized) {
+        return { error: `字段 ${column.name} 需要字符串数组，或逗号分隔字符串。` };
+      }
+      if (Array.isArray(column.options) && column.options.length > 0) {
+        const invalid = normalized.filter((item) => !column.options?.includes(item));
+        if (invalid.length > 0) {
+          return {
+            error: `字段 ${column.name} 包含非法选项：${invalid.join(", ")}。允许值：${column.options.join(", ")}。`,
+          };
+        }
+      }
+      return { value: normalized };
+    }
+    case "text":
+    default: {
+      if (typeof rawValue === "string") return { value: rawValue };
+      if (
+        typeof rawValue === "number" ||
+        typeof rawValue === "boolean"
+      ) {
+        return { value: String(rawValue) };
+      }
+      return { value: rawValue };
+    }
+  }
+};
+
+export const normalizeRowValues = (
+  columns: TableColumn[],
+  values: Record<string, any>,
+  options: NormalizeRowOptions = {}
+): NormalizeRowResult => {
+  const mode = options.mode ?? "create";
+  const allowedColumns = new Map(columns.map((column) => [column.name, column]));
+  const sanitizedValues: Record<string, any> = {};
+  const ignoredColumns: string[] = [];
+  const errors: string[] = [];
+
+  for (const [key, value] of Object.entries(values || {})) {
+    if (RESERVED_ROW_KEYS.has(key)) {
+      ignoredColumns.push(key);
+      continue;
+    }
+
+    const column = allowedColumns.get(key);
+    if (!column) {
+      ignoredColumns.push(key);
+      continue;
+    }
+
+    const normalized = normalizeSingleValue(column, value);
+    if (normalized.error) {
+      errors.push(normalized.error);
+      continue;
+    }
+
+    if (normalized.value !== undefined) {
+      sanitizedValues[key] = normalized.value;
+    }
+  }
+
+  if (mode === "create") {
+    const missingRequired = columns
+      .filter((column) => column.required)
+      .filter((column) => isBlank(sanitizedValues[column.name]))
+      .map((column) => column.name);
+
+    if (missingRequired.length > 0) {
+      errors.push(`缺少必填字段：${missingRequired.join(", ")}。`);
+    }
+  }
+
+  return {
+    sanitizedValues,
+    ignoredColumns,
+    errors,
+  };
+};
+
+export const applyRowFilters = (rows: any[], filters?: RowFilters): any[] => {
+  if (!filters || Object.keys(filters).length === 0) return rows;
+
+  return rows.filter((row) =>
+    Object.entries(filters).every(([key, expected]) => {
+      const { exists, value: actual } = getRowValueByPath(row, key);
+      if (!exists) return false;
+      if (Array.isArray(expected)) {
+        if (Array.isArray(actual)) {
+          return expected.every((item) => actual.includes(item));
+        }
+        return expected.includes(actual);
+      }
+      if (Array.isArray(actual)) {
+        return actual.includes(expected);
+      }
+      return actual === expected;
+    })
+  );
+};
+
+export const sortRows = (
+  rows: any[],
+  sortBy = "updatedAt",
+  sortOrder: "asc" | "desc" = "desc"
+): any[] => {
+  const factor = sortOrder === "asc" ? 1 : -1;
+  return [...rows].sort((a, b) => {
+    const left = getRowValueByPath(a, sortBy).value;
+    const right = getRowValueByPath(b, sortBy).value;
+
+    if (left == null && right == null) return 0;
+    if (left == null) return 1;
+    if (right == null) return -1;
+
+    if (typeof left === "number" && typeof right === "number") {
+      return (left - right) * factor;
+    }
+
+    const leftTs = Date.parse(String(left));
+    const rightTs = Date.parse(String(right));
+    if (Number.isFinite(leftTs) && Number.isFinite(rightTs)) {
+      return (leftTs - rightTs) * factor;
+    }
+
+    return String(left).localeCompare(String(right)) * factor;
+  });
+};
+
+export const pickRowColumns = (
+  row: any,
+  columns?: string[],
+  options: { includeBaseFields?: boolean } = {}
+): any => {
+  if (!Array.isArray(columns) || columns.length === 0) return row;
+
+  const picked: Record<string, any> = {};
+  for (const key of columns) {
+    const { exists, value } = getRowValueByPath(row, key);
+    if (exists) {
+      setValueByPath(picked, key, value);
+    }
+  }
+
+  if (options.includeBaseFields !== false) {
+    for (const baseKey of ["dbKey", "rowId", "tenantId", "tableId", "createdAt", "updatedAt"]) {
+      if (baseKey in row) {
+        picked[baseKey] = row[baseKey];
+      }
+    }
+  }
+
+  return picked;
+};
+
+export const formatKnownColumns = (tableMeta: TableMeta): string =>
+  tableMeta.columns.map((column) => column.name).join(", ") || "(无列定义)";

package/render/table/types.ts

@@ -0,0 +1,252 @@
+// 文件: render/table/types.ts
+
+import { DataType } from "../../create/types";
+
+/* --------------------------------------------------------------------------
+ * 1. 列类型（TableColumn）
+ * ------------------------------------------------------------------------*/
+
+export type TableColumnType =
+    | "text"
+    | "number"
+    | "boolean"
+    | "date"
+    | "datetime"
+    | "select"
+    | "multi_select";
+// 将来可以扩展: "relation" | "json" | "file" 等
+
+/**
+ * 表字段定义（列）
+ *
+ * 说明：
+ * - id：列自身的稳定 ID，供公式 / 视图 / 触发器 / Agent 配置引用
+ * - name：行数据中的 key（machine name）
+ * - label：展示名，可中文；不填时 UI 回退为 name
+ * - type + required + options：构成字段的“域约束”
+ * - description：给人和 AI 的语义说明
+ * - isPrimary：标记“这一行是谁”的主字段（行标题）
+ */
+export interface TableColumn {
+    /** 列内部 ID（稳定，不随 name 改动） */
+    id: string;
+
+    /** 行中的字段名（机器名），建议英文/拼音，无空格 */
+    name: string;
+
+    /** 字段显示名，可中文；不填时 UI 用 name */
+    label?: string;
+
+    /** 字段类型（默认 text） */
+    type?: TableColumnType;
+
+    /** 字段说明：给人和 AI 看的描述 */
+    description?: string;
+
+    /** 是否为主字段（行标题），类似 Notion 的 Name 列 */
+    isPrimary?: boolean;
+
+    /** 是否必填 */
+    required?: boolean;
+
+    /**
+     * 离散取值集合，仅在 type 为 select / multi_select 时有意义。
+     * 先用 string[] 简化，将来可以扩展为对象数组（带颜色/顺序等）。
+     */
+    options?: string[];
+
+    /**
+     * 自定义列宽（像素），仅影响 UI 展示。
+     * - 不设置时由浏览器根据内容自适应宽度；
+     * - 设置后在所有视图中保持一致宽度（后续可以细化到 view 级别）。
+     */
+    width?: number;
+}
+
+/**
+ * 创建表时，传入的列配置：
+ * - id 由系统生成，外部一般不传
+ */
+export type CreateTableColumnInput = Omit<TableColumn, "id">;
+
+/* --------------------------------------------------------------------------
+ * 2. 视图（TableView）
+ * ------------------------------------------------------------------------*/
+
+export type TableViewType = "grid" | "kanban" | "calendar";
+
+export type SortDirection = "asc" | "desc";
+
+/**
+ * 简化版排序规则
+ */
+export interface TableViewSortRule {
+    columnId: string; // 引用 TableColumn.id
+    direction: SortDirection;
+}
+
+/**
+ * 过滤规则：
+ * - 这里先保留占位，后续可以演进为一套 DSL / JSON Schema
+ */
+export interface TableViewFilter {
+    // 将来可以改成 { op: "and" | "or"; conditions: Condition[] } 等
+    [key: string]: any;
+}
+
+/**
+ * 分组配置（例如看板分组）
+ */
+export interface TableViewGroup {
+    columnId: string; // 按哪个列分组
+}
+
+/**
+ * 视图定义：
+ * - 用来描述“这一张表在某个视角下如何展示/筛选/排序”
+ * - 未来 UI 和 Agent 都可以基于 View 工作
+ */
+export interface TableView {
+    id: string;
+    name: string;
+    type: TableViewType;
+
+    /** 是否为默认视图 */
+    isDefault?: boolean;
+
+    /** 当前视图中可见的列（按列 id 排序） */
+    visibleColumnIds: string[];
+
+    /** 排序规则（可选） */
+    sort?: TableViewSortRule[];
+
+    /** 过滤规则（可选） */
+    filter?: TableViewFilter;
+
+    /** 分组（看板/分组表格） */
+    group?: TableViewGroup | null;
+
+    /**
+     * 给 AI 的附加说明：
+     * - 例如「本视图只展示未完成任务」「按项目分组」等
+     */
+    aiHint?: string;
+}
+
+/* --------------------------------------------------------------------------
+ * 3. 触发器（TableTrigger）：行变更 → Agent / Webhook 等
+ * ------------------------------------------------------------------------*/
+
+// 目前 Trigger 还没有真正落库和实现逻辑，可以仅保留类型占位，
+// 后续如做通用 Trigger 中心建议迁移到 core/events/types.ts。
+
+export type TableTriggerEvent = "row_created" | "row_updated" | "row_deleted";
+
+export type TableTriggerActionType = "agent" | "webhook" | "custom";
+
+export interface TableTriggerCondition {
+    kind: "match_column_value";
+    columnId: string; // TableColumn.id
+    operator: "eq" | "ne" | "in" | "not_in" | "contains";
+    value: any;
+}
+
+export interface TableTriggerActionConfig {
+    agentKey?: string;
+    url?: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    [key: string]: any;
+}
+
+export interface TableTrigger {
+    id: string;
+    name: string;
+    description?: string;
+    enabled: boolean;
+
+    event: TableTriggerEvent;
+    viewId?: string;
+    condition?: TableTriggerCondition;
+
+    actionType: TableTriggerActionType;
+    actionConfig?: TableTriggerActionConfig;
+}
+
+/* --------------------------------------------------------------------------
+ * 4. 表 AI 配置（TableAiConfig）
+ * ------------------------------------------------------------------------*/
+
+export interface TableAiConfig {
+    enabled: boolean;
+    purpose?: string;
+    allowedOperations?: {
+        createRow?: boolean;
+        updateRow?: boolean;
+        deleteRow?: boolean;
+        modifySchema?: boolean;
+    };
+    privacy?: {
+        maskColumnIds?: string[];
+    };
+}
+
+/* --------------------------------------------------------------------------
+ * 5. 表 Meta（TableMeta）
+ * ------------------------------------------------------------------------*/
+
+/**
+ * 表的元信息：
+ * - 跟具体存储键（meta-{tenantId}-{tableId}）一一对应
+ * - 是 schema + 视图 + 触发器 + AI 配置的集中描述
+ *
+ * Invariant:
+ * - 对任意 TableMeta(dbKey = meta-{tenantId}-{tableId})，
+ *   所有行必须满足 row.tenantId === tenantId 且 row.tableId === tableId。
+ */
+export interface TableMeta {
+    /** meta dbKey: meta-{tenantId}-{tableId} */
+    dbKey: string;
+
+    tenantId: string;
+    tableId: string;
+    spaceId?: string | null;
+
+    /** 表显示名（可中文） */
+    displayName?: string;
+
+    /**
+     * 表用途说明，给人和 AI 都看的版本：
+     * 建议包括：
+     * - 每一行代表什么
+     * - 这张表大致用来干什么
+     */
+    description?: string;
+
+    /**
+     * 任意关键词标签，仅供 AI / 系统使用：
+     * 例如 ["记账","交易","财务"] / ["衣服","穿搭","旅行"]。
+     * 用户不必手动维护，可由 Agent 在创建表时自动填入。
+     */
+    tags?: string[];
+
+    /** schema 版本号，用于将来迁移，起步可以固定为 1 */
+    schemaVersion?: number;
+
+    /** 列定义 */
+    columns: TableColumn[];
+
+    /** 视图列表（可选） */
+    views?: TableView[];
+
+    /** 表级触发器列表（可选） */
+    triggers?: TableTrigger[];
+
+    /** AI 配置（可选） */
+    aiConfig?: TableAiConfig;
+
+    createdAt: string;
+    updatedAt: string;
+
+    /** 类型标记：table */
+    type: DataType.TABLE;
+}

package/render/table/utils/tableSerialization.ts

@@ -0,0 +1,50 @@
+// packages/render/table/utils/tableSerialization.ts
+
+import { TableMeta } from "../../table/types";
+import { fetchAndCacheTableRows } from "../fetchAndCacheTableRows";
+
+/**
+ * Fetches all rows for a given table from the database and serializes the metadata 
+ * and rows into a structured Markdown format.
+ */
+export const fetchAndSerializeTable = async (
+    tableMeta: TableMeta,
+    db: any,
+    options: {
+        token?: string | null;
+        remoteServers?: string[];
+    } = {}
+): Promise<{ rows: any[]; markdown: string }> => {
+    const tenantId = tableMeta.tenantId;
+    const tableId = tableMeta.tableId;
+    const results = await fetchAndCacheTableRows({
+        db,
+        tenantId,
+        tableId,
+        token: options.token,
+        remoteServers: options.remoteServers ?? [],
+    });
+
+    // Format as Markdown table
+    const columns = tableMeta.columns || [];
+    const headerRow = columns.map((c) => c.label || c.name);
+    const separatorRow = columns.map(() => "---");
+
+    let tableMd = "";
+    if (columns.length > 0) {
+        tableMd = `| ${headerRow.join(" | ")} |\n| ${separatorRow.join(" | ")} |\n`;
+        results.forEach((row: any) => {
+            const rowData = columns.map((col) => {
+                const val = row[col.name];
+                return val === undefined || val === null
+                    ? ""
+                    : String(val).replace(/\|/g, "\\|");
+            });
+            tableMd += `| ${rowData.join(" | ")} |\n`;
+        });
+    } else {
+        tableMd = "(No columns defined for this table)";
+    }
+
+    return { rows: results, markdown: tableMd };
+};