nolo-cli 0.1.21 → 0.1.23

package/render/table/tableView.ts

@@ -0,0 +1,289 @@
+import type { TableColumn, TableMeta, TableView } from "./types";
+
+export const NOLO_TASK_BOARD_TABLE_ID = "NOLOTASKBOARD";
+
+export type TableDisplayMode =
+  | { type: "grid" }
+  | {
+      type: "kanban";
+      viewName: string;
+      groupColumnName: string;
+      visibleColumnNames: string[];
+      preferredGroupValues: string[];
+    };
+
+export type TableActivityBadgeInfo = {
+  dialogId: string;
+  dialogKey?: string;
+  status?: string;
+  label: string;
+  title: string;
+  tone: "neutral" | "running" | "success" | "danger";
+};
+
+const TASK_BOARD_STATUS_ORDER = [
+  "待处理",
+  "进行中",
+  "阻塞",
+  "等待确认",
+  "已完成",
+];
+
+const ACTIVITY_STATUS_LABELS: Record<string, string> = {
+  pending: "等待中",
+  queued: "等待中",
+  accepted: "已接收",
+  running: "运行中",
+  completed: "已完成",
+  failed: "失败",
+  failed_to_start: "启动失败",
+  timed_out: "超时",
+};
+
+function findColumnById(columns: TableColumn[], columnId?: string) {
+  if (!columnId) return null;
+  return columns.find((column) => column.id === columnId) ?? null;
+}
+
+function findColumnByName(columns: TableColumn[], columnName: string) {
+  return columns.find((column) => column.name === columnName) ?? null;
+}
+
+export function findColumnByNameOrLabel(
+  columns: TableColumn[],
+  candidates: string[]
+) {
+  const normalizedCandidates = candidates.map((candidate) => candidate.trim());
+  return (
+    columns.find((column) => normalizedCandidates.includes(column.name)) ??
+    columns.find(
+      (column) =>
+        typeof column.label === "string" &&
+        normalizedCandidates.includes(column.label.trim())
+    ) ??
+    null
+  );
+}
+
+function visibleNamesFromView(columns: TableColumn[], view: TableView) {
+  if (!Array.isArray(view.visibleColumnIds) || view.visibleColumnIds.length === 0) {
+    return columns.map((column) => column.name);
+  }
+  const names = view.visibleColumnIds
+    .map((columnId) => findColumnById(columns, columnId)?.name)
+    .filter((name): name is string => Boolean(name));
+  return names.length > 0 ? names : columns.map((column) => column.name);
+}
+
+function valuesForGroupColumn(column: TableColumn) {
+  if (Array.isArray(column.options) && column.options.length > 0) {
+    return column.options;
+  }
+  if (column.name === "status") {
+    return TASK_BOARD_STATUS_ORDER;
+  }
+  return [];
+}
+
+export function getColumnFilterOptions(
+  rows: Record<string, unknown>[],
+  column: Pick<TableColumn, "name" | "options"> | null
+) {
+  if (!column) return [];
+
+  const values = new Set<string>();
+  const orderedValues: string[] = [];
+  const rowOnlyValues = new Set<string>();
+  if (Array.isArray(column.options)) {
+    column.options.forEach((option) => {
+      const value = String(option ?? "").trim();
+      if (value && !values.has(value)) {
+        values.add(value);
+        orderedValues.push(value);
+      }
+    });
+  }
+
+  rows.forEach((row) => {
+    const value = String(row[column.name] ?? "").trim();
+    if (value && !values.has(value)) {
+      values.add(value);
+      rowOnlyValues.add(value);
+    }
+  });
+
+  return [
+    ...orderedValues,
+    ...Array.from(rowOnlyValues).sort((a, b) => a.localeCompare(b, "zh-Hans-CN")),
+  ];
+}
+
+export function filterRowsByTableFilters<T extends Record<string, unknown>>(
+  rows: T[],
+  filters: {
+    statusColumnName: string | null;
+    statusValue: string;
+    ownerColumnName: string | null;
+    ownerValue: string;
+  }
+) {
+  const statusValue = filters.statusValue.trim();
+  const ownerValue = filters.ownerValue.trim();
+
+  return rows.filter((row) => {
+    if (
+      statusValue &&
+      filters.statusColumnName &&
+      String(row[filters.statusColumnName] ?? "").trim() !== statusValue
+    ) {
+      return false;
+    }
+
+    if (
+      ownerValue &&
+      filters.ownerColumnName &&
+      String(row[filters.ownerColumnName] ?? "").trim() !== ownerValue
+    ) {
+      return false;
+    }
+
+    return true;
+  });
+}
+
+function normalizeActivityRef(value: unknown) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const ref = value as Record<string, unknown>;
+  if (ref.type !== "dialog") return null;
+  const dialogId = typeof ref.dialogId === "string" ? ref.dialogId.trim() : "";
+  if (!dialogId) return null;
+  const dialogKey = typeof ref.dialogKey === "string" && ref.dialogKey.trim()
+    ? ref.dialogKey.trim()
+    : undefined;
+  const status = typeof ref.status === "string" && ref.status.trim()
+    ? ref.status.trim()
+    : undefined;
+  return { dialogId, dialogKey, status };
+}
+
+function activityTone(status?: string): TableActivityBadgeInfo["tone"] {
+  if (status === "running") return "running";
+  if (status === "completed") return "success";
+  if (status === "failed" || status === "failed_to_start" || status === "timed_out") {
+    return "danger";
+  }
+  return "neutral";
+}
+
+function shortDialogId(dialogId: string) {
+  return dialogId.length > 10 ? `${dialogId.slice(0, 6)}…${dialogId.slice(-4)}` : dialogId;
+}
+
+export function getLatestTableActivityBadge(row: Record<string, unknown>): TableActivityBadgeInfo | null {
+  const meta = row?.meta;
+  const metaRecord =
+    meta && typeof meta === "object" && !Array.isArray(meta) ? (meta as Record<string, unknown>) : null;
+  if (!metaRecord) return null;
+
+  const latest =
+    normalizeActivityRef(metaRecord.latestActivityRef) ??
+    (Array.isArray(metaRecord.activityRefs)
+      ? normalizeActivityRef(metaRecord.activityRefs[metaRecord.activityRefs.length - 1])
+      : null);
+  if (!latest) return null;
+
+  const statusLabel = latest.status ? ACTIVITY_STATUS_LABELS[latest.status] ?? latest.status : "对话";
+  return {
+    ...latest,
+    label: `${statusLabel} · ${shortDialogId(latest.dialogId)}`,
+    title: `Dialog ${latest.dialogId}${latest.status ? ` · ${statusLabel}` : ""}`,
+    tone: activityTone(latest.status),
+  };
+}
+
+const MARKDOWN_TABLE_SEPARATOR_CELL = /^:?-{3,}:?$/;
+
+function markdownTableCellCount(line: string) {
+  const trimmed = line.trim();
+  if (!trimmed.includes("|")) return 0;
+
+  const content =
+    trimmed.startsWith("|") && trimmed.endsWith("|")
+      ? trimmed.slice(1, -1)
+      : trimmed;
+  const cells = content.split("|").map((cell) => cell.trim());
+  return cells.length >= 2 && cells.every((cell) => cell.length > 0)
+    ? cells.length
+    : 0;
+}
+
+function isMarkdownTableSeparator(line: string) {
+  const trimmed = line.trim();
+  if (!trimmed.includes("|")) return false;
+
+  const content =
+    trimmed.startsWith("|") && trimmed.endsWith("|")
+      ? trimmed.slice(1, -1)
+      : trimmed;
+  const cells = content.split("|").map((cell) => cell.trim());
+  return (
+    cells.length >= 2 &&
+    cells.every((cell) => MARKDOWN_TABLE_SEPARATOR_CELL.test(cell))
+  );
+}
+
+export function containsMarkdownTable(value: string) {
+  const lines = value.split(/\r?\n/);
+
+  for (let index = 1; index < lines.length; index += 1) {
+    if (!isMarkdownTableSeparator(lines[index])) continue;
+
+    const headerCellCount = markdownTableCellCount(lines[index - 1]);
+    if (headerCellCount < 2) continue;
+
+    const separatorCellCount = markdownTableCellCount(lines[index]);
+    if (separatorCellCount === headerCellCount) return true;
+  }
+
+  return false;
+}
+
+export function shouldRenderKanbanMarkdownTable(tableId: string | undefined, value: string) {
+  return tableId === NOLO_TASK_BOARD_TABLE_ID && containsMarkdownTable(value);
+}
+
+export function resolveTableDisplayMode(tableMeta: Pick<TableMeta, "tableId" | "columns" | "views">): TableDisplayMode {
+  const columns = Array.isArray(tableMeta.columns) ? tableMeta.columns : [];
+  const views = Array.isArray(tableMeta.views) ? tableMeta.views : [];
+  const defaultView = views.find((view) => view.isDefault) ?? views[0];
+
+  if (defaultView?.type === "kanban") {
+    const groupColumn = findColumnById(columns, defaultView.group?.columnId);
+    if (groupColumn) {
+      return {
+        type: "kanban",
+        viewName: defaultView.name || "看板",
+        groupColumnName: groupColumn.name,
+        visibleColumnNames: visibleNamesFromView(columns, defaultView),
+        preferredGroupValues: valuesForGroupColumn(groupColumn),
+      };
+    }
+  }
+
+  if (tableMeta.tableId === NOLO_TASK_BOARD_TABLE_ID) {
+    const statusColumn = findColumnByName(columns, "status");
+    if (statusColumn) {
+      return {
+        type: "kanban",
+        viewName: "看板",
+        groupColumnName: statusColumn.name,
+        visibleColumnNames: ["title", "tags", "priority", "owner", "progress", "result"].filter((name) =>
+          Boolean(findColumnByName(columns, name))
+        ),
+        preferredGroupValues: TASK_BOARD_STATUS_ORDER,
+      };
+    }
+  }
+
+  return { type: "grid" };
+}

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(", ") || "(无列定义)";