nolo-cli 0.1.31 → 0.1.32

package/ai/tools/surfWeatherTool.ts

@@ -1,169 +0,0 @@
-export interface SurfWeatherToolArgs {
-  latitude: number;
-  longitude: number;
-  location_name?: string;
-  forecast_days?: number;
-}
-
-export const surfWeatherFunctionSchema = {
-  name: "surfWeather",
-  description: [
-    "获取指定海岸位置的冲浪天气预报，包括浪高、涌浪高度、浪周期、涌浪周期、浪向等关键指标。",
-    "数据来源：Open-Meteo Marine API（免费，无需 API Key）。",
-    "适用场景：查询某个冲浪点未来几天的海浪状况，判断是否适合冲浪。",
-  ].join("\n"),
-  parameters: {
-    type: "object",
-    properties: {
-      latitude: {
-        type: "number",
-        description: "纬度，例如海南万宁为 18.8",
-      },
-      longitude: {
-        type: "number",
-        description: "经度，例如海南万宁为 110.4",
-      },
-      location_name: {
-        type: "string",
-        description: "地点名称（可选），仅用于展示，例如「海南万宁日月湾」",
-      },
-      forecast_days: {
-        type: "number",
-        description: "预报天数，1~7，默认 3",
-      },
-    },
-    required: ["latitude", "longitude"],
-  },
-} as const;
-
-interface HourlyData {
-  time: string[];
-  wave_height: number[];
-  wave_period: number[];
-  wave_direction: number[];
-  wind_wave_height: number[];
-  swell_wave_height: number[];
-  swell_wave_period: number[];
-  swell_wave_direction: number[];
-}
-
-function getSurfRating(waveHeight: number, wavePeriod: number): string {
-  if (waveHeight < 0.3) return "⚫ 无浪";
-  if (waveHeight < 0.6 && wavePeriod < 6) return "🟤 极差";
-  if (waveHeight < 0.8) return "🔴 差";
-  if (waveHeight < 1.2 && wavePeriod >= 6) return "🟡 一般";
-  if (waveHeight < 2.0 && wavePeriod >= 8) return "🟢 较好";
-  if (waveHeight >= 2.0 && wavePeriod >= 10) return "🔵 优秀";
-  return "🟡 一般";
-}
-
-function getWindDirection(deg: number): string {
-  const dirs = ["北", "东北", "东", "东南", "南", "西南", "西", "西北"];
-  return dirs[Math.round(deg / 45) % 8];
-}
-
-export async function surfWeatherFunc(
-  args: SurfWeatherToolArgs
-): Promise<{ rawData: unknown; displayData: string }> {
-  const { latitude, longitude, location_name, forecast_days = 3 } = args;
-
-  const days = Math.min(Math.max(Math.round(forecast_days), 1), 7);
-  const params = [
-    "wave_height",
-    "wave_period",
-    "wave_direction",
-    "wind_wave_height",
-    "swell_wave_height",
-    "swell_wave_period",
-    "swell_wave_direction",
-  ].join(",");
-
-  const url =
-    `https://marine-api.open-meteo.com/v1/marine` +
-    `?latitude=${latitude}&longitude=${longitude}` +
-    `&hourly=${params}` +
-    `&timezone=Asia/Shanghai` +
-    `&forecast_days=${days}`;
-
-  const res = await fetch(url);
-  if (!res.ok) {
-    throw new Error(`Open-Meteo API 请求失败: ${res.status} ${res.statusText}`);
-  }
-
-  const data = (await res.json()) as {
-    latitude: number;
-    longitude: number;
-    hourly: HourlyData;
-  };
-
-  const h = data.hourly;
-  const locationLabel = location_name || `${data.latitude}°N, ${data.longitude}°E`;
-
-  // 每天取最大浪高时段作为日摘要（取 08:00 - 20:00 峰值）
-  const dailySummaries: {
-    date: string;
-    maxWaveHeight: number;
-    wavePeriod: number;
-    swellHeight: number;
-    swellPeriod: number;
-    waveDirection: number;
-    rating: string;
-  }[] = [];
-
-  const totalHours = h.time.length;
-  for (let d = 0; d < days; d++) {
-    const start = d * 24;
-    const end = Math.min(start + 24, totalHours);
-    // 找当天最大浪高的小时
-    let bestIdx = start;
-    for (let i = start; i < end; i++) {
-      const hour = parseInt(h.time[i].slice(11, 13), 10);
-      if (hour < 8 || hour > 20) continue;
-      if (h.wave_height[i] > h.wave_height[bestIdx]) bestIdx = i;
-    }
-    const date = h.time[bestIdx].slice(0, 10);
-    const wh = h.wave_height[bestIdx];
-    const wp = h.wave_period[bestIdx];
-    const sh = h.swell_wave_height[bestIdx];
-    const sp = h.swell_wave_period[bestIdx];
-    const wd = h.wave_direction[bestIdx];
-    dailySummaries.push({
-      date,
-      maxWaveHeight: wh,
-      wavePeriod: wp,
-      swellHeight: sh,
-      swellPeriod: sp,
-      waveDirection: wd,
-      rating: getSurfRating(wh, wp),
-    });
-  }
-
-  // 构建展示文本
-  const lines: string[] = [];
-  lines.push(`🏄 冲浪天气预报 — ${locationLabel}`);
-  lines.push(`数据来源：Open-Meteo Marine API\n`);
-  lines.push(`日期          评级      浪高    涌浪    周期  涌浪周期  浪向`);
-  lines.push("─".repeat(58));
-
-  for (const s of dailySummaries) {
-    lines.push(
-      `${s.date}  ${s.rating}  ${s.maxWaveHeight.toFixed(2)}m  ${s.swellHeight.toFixed(2)}m  ${s.wavePeriod.toFixed(1)}s  ${s.swellPeriod.toFixed(1)}s  ${getWindDirection(s.waveDirection)}`
-    );
-  }
-
-  lines.push("\n评级说明：🔵优秀 🟢较好 🟡一般 🔴差 🟤极差 ⚫无浪");
-
-  const displayData = lines.join("\n");
-
-  return {
-    rawData: {
-      location: locationLabel,
-      latitude: data.latitude,
-      longitude: data.longitude,
-      forecast_days: days,
-      daily: dailySummaries,
-      hourly: h,
-    },
-    displayData,
-  };
-}

package/ai/tools/table/addTableRowTool.ts

@@ -1,217 +0,0 @@
-// 文件: ai/tools/table/addTableRowTool.ts
-
-import type { RootState } from "../../../app/store";
-import { addRow } from "../../../render/table/tableSlice";
-
-/**
- * [Schema] addTableRow：在当前已打开的表中新增一行数据
- *
- * 设计要点：
- * - 默认情况下，从当前 Redux 状态里的 tableSlice.currentTable 推断 tenantId / tableId
- * - LLM 主要只需要关心 values（列名 -> 值）
- * - 如果没有当前表，又没显式传 tenantId / tableId，则报错
- */
-export const addTableRowFunctionSchema = {
-    name: "addTableRow",
-    description:
-        [
-            "在指定表中新增一行数据。",
-            "【重要】如果你是在对话（chat）中调用此函数（而非在表格页面的「页面助手」中），",
-            "则必须显式传入 tenantId 和 tableId。这两个值可从 createTable 的返回结果中获取。",
-            "如果你刚刚调用了 createTable，请务必将其返回的 tenantId 和 tableId 传入此函数。",
-            "只有在表格页面打开「页面助手」时，tenantId 和 tableId 才可以省略（会自动推断）。",
-            "【重要】表格字段必须放在 values 对象里，不要把 content、status 这类列名直接放在顶层。",
-            '完整示例：{"tenantId":"u1","tableId":"t1","values":{"content":"希望支持支付宝支付","status":"待处理"}}。',
-        ].join("\n"),
-    parameters: {
-        type: "object",
-        properties: {
-            values: {
-                type: "object",
-                description:
-                    [
-                        "要写入新行的数据。key 必须是目标表已有的列名，多余字段会被忽略。",
-                        '请根据用户的自然语言描述，为每个相关字段填上合理的值，而不是传入空对象 {}。',
-                        '字段必须包在 values 中。示例：{"values": {"name": "张三", "desc": "测试任务", "date": "2025-01-01"}}。',
-                    ].join("\n"),
-                additionalProperties: {
-                    description:
-                        "单个字段的值；可以是字符串、数字、布尔值、null、对象或数组。",
-                },
-            },
-            tenantId: {
-                type: "string",
-                description:
-                    "租户 ID。在对话（chat）中调用时必须显式传入，从 createTable 的返回结果获取。",
-            },
-            tableId: {
-                type: "string",
-                description:
-                    "表 ID。在对话（chat）中调用时必须显式传入，从 createTable 的返回结果获取。",
-            },
-        },
-        required: ["values"],
-    },
-};
-
-type AddTableRowArgs = {
-    values?: Record<string, any>;
-    tenantId?: string;
-    tableId?: string;
-} & Record<string, any>;
-
-type AddTableRowResult = {
-    rawData: any;
-    displayData: string;
-};
-
-const toPreviewJson = (value: unknown, maxLength = 400): 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 RESERVED_ARG_KEYS = new Set(["tenantId", "tableId", "values"]);
-
-const extractLegacyValues = (args: AddTableRowArgs | undefined): Record<string, any> => {
-    if (!args || typeof args !== "object" || Array.isArray(args)) {
-        return {};
-    }
-
-    return Object.fromEntries(
-        Object.entries(args).filter(
-            ([key, value]) => !RESERVED_ARG_KEYS.has(key) && value !== undefined
-        )
-    );
-};
-
-/**
- * [Executor] 在当前表中新增一行
- *
- * - 优先从 args.tenantId / args.tableId 取值
- * - 否则使用 state.table.currentTable 的 tenantId / tableId
- * - 如果当前表元数据可用，会自动过滤掉不存在的列名，并在 displayData 提示
- */
-export async function addTableRowFunc(
-    args: AddTableRowArgs,
-    thunkApi: any
-): Promise<AddTableRowResult> {
-    const state = thunkApi.getState() as RootState;
-    const tableState = state.table as RootState["table"];
-
-    const currentTable = tableState.currentTable;
-
-    const tenantId = args?.tenantId ?? currentTable?.tenantId;
-    const tableId = args?.tableId ?? currentTable?.tableId;
-    const normalizedValues =
-        args?.values !== undefined ? args.values : extractLegacyValues(args);
-    const values = (normalizedValues ?? {}) as Record<string, any>;
-
-    if (!tenantId || !tableId) {
-        throw new Error(
-            "addTableRow 只能在已打开某张表的页面中调用，或显式提供 tenantId 和 tableId。"
-        );
-    }
-
-    if (!values || typeof values !== "object" || Array.isArray(values)) {
-        throw new Error(
-            'addTableRow.values 必须是一个对象（列名到值的映射，例如 { "name": "张三", "desc": "测试任务" }）。'
-        );
-    }
-
-    // 兜底：禁止传空对象 {}，要求至少提供一个字段
-    if (Object.keys(values).length === 0) {
-        const knownCols = currentTable
-            ? currentTable.columns.map((c) => c.name).join(", ") || "(无列定义)"
-            : "(当前表字段未知)";
-
-        throw new Error(
-            `addTableRow.values 不能为空：你需要至少为一个字段提供值。\n` +
-            `请根据用户的输入，从以下字段中选择并填充值：${knownCols}`
-        );
-    }
-
-    let sanitizedValues: Record<string, any> = values;
-    let ignoredColumns: string[] = [];
-
-    if (
-        currentTable &&
-        currentTable.tenantId === tenantId &&
-        currentTable.tableId === tableId
-    ) {
-        const allowedColumns = new Set(currentTable.columns.map((c) => c.name));
-
-        sanitizedValues = {};
-        ignoredColumns = [];
-
-        for (const [key, val] of Object.entries(values)) {
-            if (allowedColumns.has(key)) {
-                sanitizedValues[key] = val;
-            } else {
-                ignoredColumns.push(key);
-            }
-        }
-
-        if (
-            Object.keys(sanitizedValues).length === 0 &&
-            Object.keys(values).length > 0
-        ) {
-            const knownCols =
-                currentTable.columns.map((c) => c.name).join(", ") || "(无列定义)";
-
-            throw new Error(
-                `addTableRow 失败：提供的字段名都不在当前表中。\n` +
-                `已知字段: ${knownCols}\n` +
-                `请仅使用这些字段名作为 key。`
-            );
-        }
-    }
-
-    try {
-        const actionResult = await thunkApi.dispatch(
-            addRow({ tenantId, tableId, values: sanitizedValues })
-        );
-
-        if (!addRow.fulfilled.match(actionResult)) {
-            const msg =
-                (actionResult.payload as string) ||
-                actionResult.error?.message ||
-                "新增表行失败";
-            throw new Error(msg);
-        }
-
-        const createdRow = actionResult.payload as any;
-
-        const tableLabel =
-            currentTable?.displayName ||
-            currentTable?.tableId ||
-            tableId ||
-            "当前表";
-
-        const ignoredInfo =
-            ignoredColumns.length > 0
-                ? `\n\n注意：以下字段在当前表中不存在，已被忽略：${ignoredColumns.join(
-                    ", "
-                )}`
-                : "";
-
-        return {
-            rawData: {
-                ...createdRow,
-                values: sanitizedValues,
-            },
-            displayData:
-                `已在表「${tableLabel}」中新增一行数据。\n` +
-                `rowId: ${createdRow.rowId ?? "（无 rowId 字段）"}\n\n` +
-                `数据预览：\n${toPreviewJson(createdRow)}${ignoredInfo}`,
-        };
-    } catch (error: any) {
-        throw new Error(
-            `addTableRow 调用失败：${error?.message ?? "未知错误"}`
-        );
-    }
-}

package/ai/tools/table/createTableTool.ts

@@ -1,315 +0,0 @@
-// 文件: ai/tools/table/createTableTool.ts
-
-import { createTable } from "../../../render/table/tableSlice";
-import { SEPARATOR } from "../../../database/keys";
-
-type ColumnType =
-    | "text"
-    | "number"
-    | "boolean"
-    | "date"
-    | "datetime"
-    | "select"
-    | "multi_select";
-
-interface ToolTableColumnInput {
-    name: string;
-    label?: string;
-    type?: ColumnType;
-    description?: string;
-    required?: boolean;
-    options?: string[];
-}
-
-type CreateTableToolArgs = {
-    spaceId?: string;
-    title?: string;
-    description?: string;
-    tags?: string[];
-    categoryId?: string;
-    columns: ToolTableColumnInput[];
-    withDefaultRows?: boolean;
-};
-
-type CreateTableResult = {
-    rawData: any;
-    displayData: string;
-};
-
-/**
- * 解析 meta dbKey，得到 tenantId / tableId
- * 约定：meta-{tenantId}-{tableId}
- */
-const parseMetaKey = (dbKey: string): { tenantId: string; tableId: string } => {
-    const parts = dbKey.split(SEPARATOR);
-    if (parts[0] !== "meta" || parts.length < 3) {
-        return { tenantId: "", tableId: "" };
-    }
-    const tenantId = parts[1];
-    const tableId = parts.slice(2).join(SEPARATOR);
-    return { tenantId, tableId };
-};
-
-const toPreviewJson = (value: unknown, maxLength = 400): string => {
-    try {
-        const json = JSON.stringify(value, null, 2);
-        if (json.length <= maxLength) return json;
-        return `${json.slice(0, maxLength)}\n…(已截断)…`;
-    } catch {
-        return "[无法序列化为 JSON]";
-    }
-};
-
-/**
- * [Schema] createTable：为当前用户创建一张新表
- */
-export const createTableFunctionSchema = {
-    name: "createTable",
-    description: [
-        "在当前用户（租户）下创建一张新的结构化数据表。",
-        "根据用户的描述，设计表的标题（title）、用途说明（description）以及字段列表（columns）。",
-        "字段名建议使用简洁的英文或拼音（如 name, desc, status, dueDate），避免空格和特殊符号。",
-    ].join("\n"),
-    parameters: {
-        type: "object",
-        properties: {
-            spaceId: {
-                type: "string",
-                description:
-                    "可选：指定要创建到的 Space ID。不传则使用当前 Space。",
-            },
-            title: {
-                type: "string",
-                description:
-                    "表的显示名称，可以使用中文，例如「任务清单」「客户管理」。",
-            },
-            description: {
-                type: "string",
-                description:
-                    "表用途说明（给人和 AI 看）：建议描述每一行代表什么，以及这张表大致用来干什么。",
-            },
-            tags: {
-                type: "array",
-                items: { type: "string" },
-                description:
-                    "可选：表示该表的关键词标签列表，例如 [\"记账\",\"交易\",\"预算\"]。主要供 AI 选表使用，用户无需手动维护。",
-            },
-            categoryId: {
-                type: "string",
-                description: "可选：Space 内分类 ID。",
-            },
-            columns: {
-                type: "array",
-                description: [
-                    "要创建的字段列表，至少包含 1 个字段。",
-                    "字段顺序会按数组顺序保存。",
-                    "",
-                    "每个字段对象支持：",
-                    "- name: 字段 machine 名（英文/拼音，无空格），必填；",
-                    "- label: 字段显示名，可中文；",
-                    "- type: 字段类型，默认 text，可选：text/number/boolean/date/datetime/select/multi_select；",
-                    "- description: 字段含义说明，给人和 AI 看；",
-                    "- required: 是否必填；",
-                    "- options: 对于 select/multi_select 的可选值列表。",
-                ].join("\n"),
-                minItems: 1,
-                items: {
-                    type: "object",
-                    properties: {
-                        name: {
-                            type: "string",
-                            description:
-                                "字段名（machine name），例如 name、desc、status、dueDate。必须是单个标识符，不要包含空格。",
-                        },
-                        label: {
-                            type: "string",
-                            description:
-                                "字段显示名，可中文，例如「订单金额」「备注」。不填时前端会回退为 name。",
-                        },
-                        type: {
-                            type: "string",
-                            enum: [
-                                "text",
-                                "number",
-                                "boolean",
-                                "date",
-                                "datetime",
-                                "select",
-                                "multi_select",
-                            ],
-                            description:
-                                "字段类型，默认 text。选择类字段请使用 select 或 multi_select。",
-                        },
-                        description: {
-                            type: "string",
-                            description:
-                                "字段含义说明，既给用户也给 AI 看，例如「订单金额（单位人民币）」。",
-                        },
-                        required: {
-                            type: "boolean",
-                            description: "是否为必填字段。",
-                        },
-                        options: {
-                            type: "array",
-                            items: { type: "string" },
-                            description:
-                                "当 type 为 select 或 multi_select 时可用，表示允许的取值列表，例如 [\"created\",\"paid\",\"done\"]。",
-                        },
-                    },
-                    required: ["name"],
-                },
-            },
-            withDefaultRows: {
-                type: "boolean",
-                description:
-                    "是否自动创建两行示例数据。默认 false（AI 创建的表通常不需要示例行）。",
-            },
-        },
-        required: ["columns"],
-    },
-};
-
-/**
- * [Executor] 创建一张新表（调用 tableSlice.createTable thunk）
- */
-export async function createTableFunc(
-    args: CreateTableToolArgs,
-    thunkApi: any
-): Promise<CreateTableResult> {
-    const spaceId =
-        typeof args?.spaceId === "string" && args.spaceId.trim()
-            ? args.spaceId.trim()
-            : undefined;
-    const title =
-        typeof args?.title === "string" && args.title.trim()
-            ? args.title.trim()
-            : undefined;
-    const description =
-        typeof args?.description === "string" && args.description.trim()
-            ? args.description.trim()
-            : undefined;
-    const tags =
-        Array.isArray(args?.tags) && args.tags.length
-            ? args.tags
-                .map((t) => (typeof t === "string" ? t.trim() : ""))
-                .filter(Boolean)
-            : undefined;
-    const categoryId =
-        typeof args?.categoryId === "string" && args.categoryId.trim()
-            ? args.categoryId.trim()
-            : undefined;
-    const withDefaultRows =
-        typeof args?.withDefaultRows === "boolean" ? args.withDefaultRows : false;
-
-    const columnsInput = Array.isArray(args?.columns) ? args.columns : [];
-
-    if (columnsInput.length === 0) {
-        throw new Error(
-            "createTable.columns 至少需要包含一个字段，请根据用户需求设计字段。"
-        );
-    }
-
-    // 1. 清洗字段：去空白、去重
-    const seen = new Set<string>();
-    const sanitizedColumns: ToolTableColumnInput[] = [];
-
-    for (const col of columnsInput) {
-        if (!col || typeof col.name !== "string") continue;
-        const name = col.name.trim();
-        if (!name) continue;
-        if (seen.has(name)) continue;
-        seen.add(name);
-
-        const sanitized: ToolTableColumnInput = { name };
-
-        if (typeof col.label === "string" && col.label.trim()) {
-            sanitized.label = col.label.trim();
-        }
-        if (typeof col.type === "string") {
-            sanitized.type = col.type as ColumnType;
-        }
-        if (typeof col.description === "string" && col.description.trim()) {
-            sanitized.description = col.description.trim();
-        }
-        if (typeof col.required === "boolean") {
-            sanitized.required = col.required;
-        }
-        if (Array.isArray(col.options)) {
-            const opts = col.options
-                .map((opt) => (typeof opt === "string" ? opt.trim() : ""))
-                .filter(Boolean);
-            if (opts.length) sanitized.options = opts;
-        }
-
-        sanitizedColumns.push(sanitized);
-    }
-
-    if (sanitizedColumns.length === 0) {
-        throw new Error(
-            "createTable.columns 中没有任何有效的字段名，请为至少一个字段提供非空的 name。"
-        );
-    }
-
-    // 2. 构造 CreateTableArgs（与 render/table/createTableAction.ts 对齐）
-    const createArgs: any = {
-        spaceId,
-        title,
-        description,
-        tags,
-        categoryId,
-        columns: sanitizedColumns,
-        withDefaultRows,
-    };
-
-    try {
-        const actionResult = await thunkApi.dispatch(createTable(createArgs));
-
-        if (!createTable.fulfilled.match(actionResult)) {
-            const msg =
-                (actionResult.payload as string) ||
-                actionResult.error?.message ||
-                "创建表失败";
-            throw new Error(msg);
-        }
-
-        // createTableAction 返回的是 dbKey（string）
-        const dbKey = actionResult.payload as string;
-
-        // 解析出 tenantId / tableId
-        const { tenantId, tableId } = parseMetaKey(dbKey);
-
-        const finalTitle = title || "新建表格";
-        const colNamesForDisplay = sanitizedColumns.map((c) => c.name).join(", ");
-
-        // 给聊天前端的结构化数据，供 Tool 卡片渲染
-        const tableMetaForUi = {
-            dbKey, // meta-{tenantId}-{tableId}
-            tenantId,
-            tableId,
-            displayName: finalTitle,
-            description,
-            tags,
-            columns: sanitizedColumns, // [{ name, label?, type?, description?, required?, options? }]
-        };
-
-        return {
-            rawData: tableMetaForUi,
-            displayData:
-                `已创建新表「${finalTitle}」（tableId: ${tableId}）。\n` +
-                `字段列表：${colNamesForDisplay}\n\n` +
-                `接下来调用 addTableRow 时，请传入完整结构：\n` +
-                `{\n` +
-                `  "tenantId": "${tenantId}",\n` +
-                `  "tableId": "${tableId}",\n` +
-                `  "values": {\n` +
-                `    "列名": "字段值"\n` +
-                `  }\n` +
-                `}\n\n` +
-                `服务器返回 dbKey：\n${toPreviewJson(dbKey)}`,
-        };
-    } catch (error: any) {
-        throw new Error(
-            `createTable 调用失败：${error?.message ?? "未知错误"}`
-        );
-    }
-}