nolo-cli 0.1.44 → 0.1.46

package/render/table/toolValueUtils.ts

@@ -1,363 +0,0 @@
-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

@@ -1,262 +0,0 @@
-// 文件: render/table/types.ts
-
-import { DataType } from "../../create/types";
-import type { ContentIcon } from "../contentIcon/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;
-
-    /** 表格自定义图标；未设置时 UI 使用默认表格图标。 */
-    icon?: ContentIcon | null;
-
-    /**
-     * 机器可读用途，用于在当前用户/space 范围内查找某类表。
-     * 例如 agent_eval_workbench。
-     */
-    purpose?: 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

@@ -1,50 +0,0 @@
-// 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 };
-};