nolo-cli 0.1.10 → 0.1.11

package/ai/tools/createSkillDocTool.ts

@@ -1,155 +0,0 @@
-import { createDoc } from "render/page/docSlice";
-import { selectCurrentSpaceId } from "create/space/spaceSlice";
-import type { RootState } from "app/store";
-import {
-  buildSkillDocFromArgs,
-  type CreateSkillDocArgs,
-} from "ai/skills/skillDocBuilder";
-import { buildSkillFollowupResult } from "./skillFollowup";
-
-export interface CreateSkillDocToolArgs extends CreateSkillDocArgs {
-  spaceId?: string;
-  categoryId?: string;
-}
-
-export const createSkillDocFunctionSchema = {
-  name: "createSkillDoc",
-  description: [
-    "创建一个本地 skill 文档，并自动写入隐藏的 skill-config / eval-config 协议块。",
-    "适合把某个能力流程沉淀成可被 agent 引用的 skill，而不是手写协议注释。",
-    "创建成功后，如果用户还没说明下一步，优先调用 ui_ask_choice 继续询问：仅保存、挂到现有 Agent，还是新建一个 Agent 来使用它。",
-  ].join("\n"),
-  parameters: {
-    type: "object",
-    properties: {
-      title: {
-        type: "string",
-        description: "可选：文档标题。未提供时回退到 name。",
-      },
-      name: {
-        type: "string",
-        description: "可选：skill 名称。未提供时回退到 title。",
-      },
-      description: {
-        type: "string",
-        description: "必填：skill 的用途说明。",
-      },
-      body: {
-        type: "string",
-        description: "可选：skill 的正文说明、步骤、注意事项等 Markdown 内容。",
-      },
-      spaceId: {
-        type: "string",
-        description: '可选：目标 spaceId；不传则优先使用当前 space。可传空字符串 ""。',
-      },
-      categoryId: {
-        type: "string",
-        description: '可选：目标分类 categoryId；不传时传空字符串 ""。',
-      },
-      toolNames: {
-        type: "array",
-        items: { type: "string" },
-        description: "可选：该 skill 绑定的工具名列表。",
-      },
-      requiredSkills: {
-        type: "array",
-        items: { type: "string" },
-        description: "可选：硬依赖的 skill key/page key 列表。",
-      },
-      recommendedSkills: {
-        type: "array",
-        items: { type: "string" },
-        description: "可选：推荐但不强制的 skill key/page key 列表。",
-      },
-      promptPatch: {
-        type: "string",
-        description: "可选：附加到 system prompt 的技能提示。",
-      },
-      budgetTier: {
-        type: "string",
-        enum: ["low", "medium", "high"],
-        description: "可选：该 skill 的预算等级。",
-      },
-      dispatchPreferred: {
-        type: "boolean",
-        description: "可选：是否建议优先走 agent dispatch 而不是直接本 agent 执行。",
-      },
-      modalities: {
-        type: "array",
-        items: { type: "string", enum: ["text", "image", "video", "audio", "3d"] },
-        description: "可选：该 skill 涉及的模态。",
-      },
-      preferredAgents: {
-        type: "array",
-        items: { type: "string" },
-        description: "可选：更适合执行该 skill 的 agent 名称或 key。",
-      },
-      discoverKeywords: {
-        type: "array",
-        items: { type: "string" },
-        description: "可选：触发/发现关键字。",
-      },
-      discoverExamples: {
-        type: "array",
-        items: { type: "string" },
-        description: "可选：示例任务或问法。",
-      },
-      evalCases: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            input: { type: "string" },
-            expectedTools: {
-              type: "array",
-              items: { type: "string" },
-            },
-            expectedSignals: {
-              type: "array",
-              items: { type: "string" },
-            },
-            forbiddenSignals: {
-              type: "array",
-              items: { type: "string" },
-            },
-          },
-          required: ["input"],
-        },
-        description: "可选：skill 的评估用例，写入 eval-config。",
-      },
-    },
-    required: ["description"],
-  } as const,
-};
-
-export async function createSkillDocFunc(
-  args: CreateSkillDocToolArgs,
-  thunkApi: any
-): Promise<{ rawData: unknown; displayData: string }> {
-  const { dispatch, getState } = thunkApi;
-  const state = getState() as RootState;
-  const { title, content, skillConfig, evalConfig } = buildSkillDocFromArgs(args);
-
-  const explicitSpaceId = (args.spaceId ?? "").trim() || undefined;
-  const currentSpaceId = selectCurrentSpaceId(state) || undefined;
-  const spaceId = explicitSpaceId ?? currentSpaceId;
-  const categoryId = (args.categoryId ?? "").trim() || undefined;
-
-  const id = await (dispatch as any)(
-    (createDoc as any)({
-      title,
-      spaceId,
-      categoryId,
-      content,
-    })
-  ).unwrap();
-
-  return buildSkillFollowupResult({
-    dbKey: id,
-    title,
-    skillId: skillConfig.id,
-    spaceId: spaceId ?? null,
-    toolNames: skillConfig.toolNames ?? [],
-    hasEvalConfig: !!evalConfig,
-  });
-}

package/ai/tools/createWorkflowTool.ts

@@ -1,154 +0,0 @@
-/**
- * createWorkflow tool
- *
- * LLM calls this ONCE to define and immediately execute a workflow.
- * The execution engine runs all steps deterministically — no further
- * LLM involvement needed for orchestration, so token cost is O(1)
- * regardless of step count.
- *
- * Use when the task path is known upfront.
- * Use agent loop when the path needs dynamic discovery.
- */
-
-import { runWorkflow } from "ai/workflow/workflowExecutor";
-import type {
-  WorkflowDefinition,
-  WorkflowStep,
-} from "ai/workflow/workflowTypes";
-
-export const createWorkflowFunctionSchema = {
-  name: "createWorkflow",
-  description:
-    "当你已知完整执行路径时使用本工具。定义一个多步骤 workflow，引擎自动执行全部步骤，" +
-    "不需要每步都调用 LLM 决策，大幅节省 token。" +
-    "步骤类型：" +
-    "'tool'——直接执行注册工具；" +
-    "'llm'——单次 LLM 调用（无 tool loop）；" +
-    "'parallel'——子步骤并发执行；" +
-    "'condition'——纯逻辑判断分支，无需 LLM。" +
-    "步骤间通过 {{steps.STEP_ID.result}} 传递数据。",
-  parameters: {
-    type: "object",
-    properties: {
-      title: {
-        type: "string",
-        description: "Workflow 标题，简明描述整体目标。",
-      },
-      steps: {
-        type: "array",
-        description: "有序步骤列表。每步声明类型和所需参数，引擎顺序执行（parallel 步骤内部并发）。",
-        items: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string",
-              description: "步骤唯一 ID，后续步骤通过 {{steps.ID.result}} 引用。",
-            },
-            type: {
-              type: "string",
-              enum: ["tool", "llm", "parallel", "condition"],
-              description: "步骤类型。",
-            },
-            title: {
-              type: "string",
-              description: "步骤人类可读描述（可选）。",
-            },
-            // tool step
-            tool: {
-              type: "string",
-              description: "type='tool' 时必填，工具名称。",
-            },
-            args: {
-              type: "object",
-              description:
-                "type='tool' 时必填，工具参数。支持 {{steps.ID.result}} 和 {{steps.ID.result[N]}} 占位符。" +
-                "parallel 子步骤结果也可直接通过其自身 ID 引用，例如 {{steps.subStepId.result}}。",
-            },
-            // llm step
-            prompt: {
-              type: "string",
-              description: "type='llm' 时必填，发送给模型的 prompt。支持占位符。",
-            },
-            model: {
-              type: "string",
-              description: "type='llm' 时可选，指定模型名。",
-            },
-            // parallel step
-            steps: {
-              type: "array",
-              description:
-                "type='parallel' 时必填，子步骤列表（tool 或 llm 类型），并发执行。" +
-                "子步骤执行完成后，其结果同时以子步骤自身 ID 注册到全局 steps map，" +
-                "后续步骤可通过 {{steps.subStepId.result}} 直接引用，无需通过父 parallel 步骤中转。",
-              items: { type: "object" },
-            },
-            // condition step
-            check: {
-              type: "string",
-              description:
-                "type='condition' 时必填，纯 JS 布尔表达式。" +
-                "steps.<stepId>.<prop> 表示某步骤结果的属性（点路径，不支持 bracket notation，无 .result 包装）。" +
-                "支持：点路径 / 字符串和数字字面量 / 布尔 null / 比较运算符 === !== > < >= <= / 逻辑运算符 && || ! / 括号。" +
-                "例: \"steps.validate.isValid === true\" 或 \"steps.score.value >= 80 && steps.flag.ok !== false\"",
-            },
-            ifTrue: {
-              type: "array",
-              items: { type: "string" },
-              description: "条件为真时执行的步骤 ID 列表，其余步骤跳过。",
-            },
-            ifFalse: {
-              type: "array",
-              items: { type: "string" },
-              description: "条件为假时执行的步骤 ID 列表，其余步骤跳过。",
-            },
-            // error handling
-            onError: {
-              type: "string",
-              enum: ["stop", "skip", "retry"],
-              description:
-                "步骤失败时策略：stop（默认，终止 workflow）/ skip（跳过，结果记为 null 继续）" +
-                "/ retry（按 retryCount 次数重试，耗尽后若仍失败则触发 stop）。",
-            },
-            retryCount: {
-              type: "integer",
-              description: "onError='retry' 时重试次数，默认 1（即最多执行 2 次）。",
-            },
-          },
-          required: ["id", "type"],
-        },
-      },
-    },
-    required: ["title", "steps"],
-  },
-};
-
-interface CreateWorkflowArgs {
-  title: string;
-  steps: WorkflowStep[];
-}
-
-export async function createWorkflowFunc(
-  args: CreateWorkflowArgs,
-  thunkApi: any
-): Promise<{ rawData: any; displayData?: string }> {
-  const { title, steps } = args;
-
-  if (!steps?.length) {
-    throw new Error("createWorkflow: steps 不能为空。");
-  }
-
-  const definition: WorkflowDefinition = { title, steps };
-
-  const { dispatch } = thunkApi;
-  const result = await dispatch(runWorkflow({ definition })).unwrap();
-
-  const completedCount = Object.values(result.results).filter(
-    (v) => v !== null && v !== undefined
-  ).length;
-
-  const displayData = result.success
-    ? `✅ **${title}** 完成，共执行 ${completedCount} 步`
-    : `❌ **${title}** 在步骤 \`${result.failedStep}\` 失败：${result.error}`;
-
-  return { rawData: result, displayData };
-}

package/ai/tools/deepseekOcrTool.ts

@@ -1,34 +0,0 @@
-import { ToolDefinition } from ".";
-import { callToolApi } from "./toolApiClient";
-
-export const deepseekOcrSchema = {
-    name: "deepseek_ocr",
-    description: "使用 deepseek-ai/DeepSeek-OCR 模型进行光学字符识别 (OCR)。擅长中英文混合文档、手写体及复杂版式的精准识别。",
-    parameters: {
-        type: "object",
-        properties: {
-            imageUrl: {
-                type: "string",
-                description: "要进行 OCR 的图片 URL、base64 编码的图片数据，或者内部文件 ID (如 'file-...')。",
-            },
-            prompt: {
-                type: "string",
-                description: "可选的提示词，用于指导模型如何提取信息（例如：'提取所有表格数据' 或 '识别图片中的所有文字'）。默认为 '识别图片中的所有文字'。",
-                default: "识别图片中的所有文字"
-            }
-        },
-        required: ["imageUrl"],
-    },
-};
-
-export const deepseekOcrFunc: ToolDefinition["executor"] = async (input: any, thunkApi) => {
-    const { imageUrl, prompt = "识别图片中的所有文字" } = input;
-
-    const data = await callToolApi(thunkApi, "/api/deepseek-ocr", { imageUrl, prompt }, { withAuth: true });
-
-    return {
-        summary: "OCR processing completed",
-        text: data.choices?.[0]?.message?.content || "No text detected",
-        rawData: data
-    };
-};

package/ai/tools/delayTool.ts

@@ -1,31 +0,0 @@
-// ai/tools/delayTool.ts
-
-export const delayFunctionSchema = {
-  name: "delay",
-  description:
-    "让计划暂停一小段时间（毫秒），用于节流批量操作（例如连续下载多个文件）。",
-  parameters: {
-    type: "object",
-    properties: {
-      ms: {
-        type: "integer",
-        description: "需要等待的时间（毫秒），建议 200~1000 之间。",
-      },
-    },
-    required: ["ms"],
-  },
-};
-
-export async function delayFunc(
-  args: { ms: number },
-  _thunkApi: any
-): Promise<{ rawData: object; displayData: string }> {
-  const ms = typeof args.ms === "number" && args.ms > 0 ? args.ms : 200;
-
-  await new Promise<void>((resolve) => setTimeout(resolve, ms));
-
-  const rawData = { success: true, ms };
-  const displayData = `已等待 ${ms} 毫秒，继续执行后续步骤。`;
-
-  return { rawData, displayData };
-}

package/ai/tools/deleteSpacesTool.ts

@@ -1,325 +0,0 @@
-import { selectUserId } from "auth/authSlice";
-import { createSpaceKey } from "create/space/spaceKeys";
-import { deleteSpace, selectAllMemberSpaces } from "create/space/spaceSlice";
-import { read } from "database/dbSlice";
-import { getRuntimeServerContext } from "database/runtimeServerContext";
-
-import {
-  buildDeleteSpacesPreview,
-  filterSpaceDeletionCandidates,
-  resolveConfirmedSpaceDeletionTargets,
-  type DeleteSpacesMatchMode,
-  type SpaceDeletionPreview,
-  type SpaceMembershipLike,
-  type SpaceRecordLike,
-} from "./deleteSpacesToolModel";
-
-export interface DeleteSpacesToolArgs {
-  query: string;
-  matchMode?: DeleteSpacesMatchMode;
-  confirmedSpaceIds?: string[];
-}
-
-interface DeleteSpacesToolDeps {
-  selectCurrentUserId: (state: any) => string | undefined;
-  selectMemberSpaces: (state: any) => SpaceMembershipLike[];
-  readSpaceRecord: (thunkApi: any, spaceId: string) => Promise<SpaceRecordLike | null>;
-  selectDeleteServers: (state: any) => string[];
-  deleteServerKey: (
-    thunkApi: any,
-    server: string,
-    dbKey: string
-  ) => Promise<{ ok: boolean; status: number; detail: string }>;
-  deleteOwnedSpace: (
-    thunkApi: any,
-    input: { spaceId: string; strategy: "delete-space-only" }
-  ) => Promise<void>;
-}
-
-export const deleteSpacesFunctionSchema = {
-  name: "deleteSpaces",
-  description: [
-    "按名称或 ID 查找并删除当前用户拥有的 Space。",
-    "这是危险操作：第一次调用会返回待删除列表并等待用户确认；确认后才执行删除。",
-    "默认只删除 Space 壳和成员关系，不删除其中挂载的 doc/dialog/file 内容。",
-    "非 owner 的 Space 会被跳过，不会删除。",
-  ].join("\n"),
-  parameters: {
-    type: "object",
-    properties: {
-      query: {
-        type: "string",
-        description:
-          "要删除的 Space 筛选词，例如 rn_owner_verify_0504，或配合 matchMode=spaceId 传入 space id。",
-      },
-      matchMode: {
-        type: "string",
-        enum: ["prefix", "exact", "contains", "spaceId"],
-        description:
-          "匹配方式。prefix=名称前缀，exact=名称完全匹配，contains=名称包含，spaceId=按 Space ID 匹配。默认 prefix。",
-        default: "prefix",
-      },
-      confirmedSpaceIds: {
-        type: "array",
-        items: { type: "string" },
-        description:
-          "可选：确认阶段要删除的 Space ID 列表。不传时，用户点击确认会删除预览列表中的全部可删除项。",
-      },
-    },
-    required: ["query"],
-  },
-};
-
-const defaultDeps: DeleteSpacesToolDeps = {
-  selectCurrentUserId: selectUserId,
-  selectMemberSpaces: (state) => selectAllMemberSpaces(state) as SpaceMembershipLike[],
-  readSpaceRecord: async (thunkApi, spaceId) => {
-    try {
-      const record = await thunkApi.dispatch(
-        read({ dbKey: createSpaceKey.space(spaceId), waitRemote: true } as any)
-      ).unwrap();
-      return record ?? null;
-    } catch {
-      return null;
-    }
-  },
-  selectDeleteServers: (state) => {
-    const { currentServer, remoteServers } = getRuntimeServerContext(state);
-    return remoteServers.length > 0
-      ? remoteServers
-      : currentServer
-        ? [currentServer]
-        : [];
-  },
-  deleteServerKey: async (thunkApi, server, dbKey) => {
-    const state = thunkApi.getState();
-    const token = state?.auth?.currentToken;
-    if (!server) {
-      return { ok: false, status: 0, detail: "missing server" };
-    }
-    if (!token) {
-      return { ok: false, status: 401, detail: "missing auth token" };
-    }
-
-    const res = await fetch(
-      `${server.replace(/\/+$/, "")}/api/v1/db/delete/${encodeURIComponent(dbKey)}`,
-      {
-        method: "DELETE",
-        headers: { Authorization: `Bearer ${token}` },
-      }
-    );
-    return {
-      ok: res.ok,
-      status: res.status,
-      detail: await res.text().catch(() => ""),
-    };
-  },
-  deleteOwnedSpace: async (thunkApi, input) => {
-    await thunkApi.dispatch(deleteSpace(input as any)).unwrap();
-  },
-};
-
-const readSpaceRecordsById = async (
-  thunkApi: any,
-  memberships: SpaceMembershipLike[],
-  deps: DeleteSpacesToolDeps
-) => {
-  const recordsById: Record<string, SpaceRecordLike | null> = {};
-
-  for (const membership of memberships) {
-    const spaceId = String(membership.spaceId ?? "").replace(/^space-/, "");
-    if (!spaceId) continue;
-    recordsById[spaceId] = await deps.readSpaceRecord(thunkApi, spaceId);
-  }
-
-  return recordsById;
-};
-
-const loadDeletionContext = async (
-  args: DeleteSpacesToolArgs,
-  thunkApi: any,
-  deps: DeleteSpacesToolDeps
-): Promise<{
-  currentUserId: string;
-  preview: SpaceDeletionPreview;
-  spaceRecordsById: Record<string, SpaceRecordLike | null>;
-  deleteServers: string[];
-}> => {
-  const state = thunkApi.getState();
-  const currentUserId = deps.selectCurrentUserId(state);
-  if (!currentUserId) {
-    throw new Error("deleteSpaces 需要当前登录用户。");
-  }
-
-  const memberships = deps.selectMemberSpaces(state);
-  const deleteServers = deps.selectDeleteServers(state);
-  const candidates = filterSpaceDeletionCandidates(memberships, {
-    query: args.query,
-    matchMode: args.matchMode,
-  });
-  const spaceRecordsById = await readSpaceRecordsById(thunkApi, candidates, deps);
-
-  const preview = buildDeleteSpacesPreview({
-    currentUserId,
-    candidates,
-    spaceRecordsById,
-  });
-
-  return { currentUserId, preview, spaceRecordsById, deleteServers };
-};
-
-const loadPreview = async (
-  args: DeleteSpacesToolArgs,
-  thunkApi: any,
-  deps: DeleteSpacesToolDeps
-): Promise<SpaceDeletionPreview> => {
-  const { preview } = await loadDeletionContext(args, thunkApi, deps);
-  return preview;
-};
-
-const spaceMemberKeysForDelete = (
-  currentUserId: string,
-  spaceId: string,
-  record: SpaceRecordLike
-) => {
-  const memberIds = new Set<string>([currentUserId]);
-  if (Array.isArray(record.members)) {
-    for (const memberId of record.members) {
-      if (typeof memberId === "string" && memberId.trim()) {
-        memberIds.add(memberId.trim());
-      }
-    }
-  } else if (record.members && typeof record.members === "object") {
-    for (const memberId of Object.keys(record.members)) {
-      if (memberId.trim()) memberIds.add(memberId.trim());
-    }
-  }
-  return Array.from(memberIds).map((memberId) =>
-    createSpaceKey.member(memberId, spaceId)
-  );
-};
-
-const formatPreview = (preview: SpaceDeletionPreview) => {
-  if (preview.deletable.length === 0 && preview.skipped.length === 0) {
-    return "没有找到匹配的 Space。";
-  }
-
-  const lines = [
-    `找到 ${preview.deletable.length} 个可删除 Space，${preview.skipped.length} 个跳过。`,
-    "",
-  ];
-
-  if (preview.deletable.length > 0) {
-    lines.push("将删除这些 Space 壳和成员关系，不删除其中 doc/dialog/file：");
-    for (const item of preview.deletable) {
-      lines.push(
-        `- ${item.name} (${item.spaceId})，成员 ${item.memberCount}，内容 ${item.contentCount}`
-      );
-    }
-    lines.push("");
-    lines.push("需要确认后才会删除。");
-  }
-
-  if (preview.skipped.length > 0) {
-    lines.push("跳过：");
-    for (const item of preview.skipped) {
-      const owner = item.ownerId ? `，owner=${item.ownerId}` : "";
-      lines.push(`- ${item.name || item.spaceId} (${item.spaceId})：${item.reason}${owner}`);
-    }
-  }
-
-  return lines.join("\n");
-};
-
-export function createDeleteSpacesToolHandlers(deps: DeleteSpacesToolDeps) {
-  return {
-    preview: async (args: DeleteSpacesToolArgs, thunkApi: any) => {
-      const preview = await loadPreview(args, thunkApi, deps);
-      return {
-        rawData: preview,
-        displayData: formatPreview(preview),
-      };
-    },
-    execute: async (args: DeleteSpacesToolArgs, thunkApi: any) => {
-      const { currentUserId, preview, spaceRecordsById, deleteServers } =
-        await loadDeletionContext(args, thunkApi, deps);
-      const confirmedIds =
-        Array.isArray(args.confirmedSpaceIds) && args.confirmedSpaceIds.length > 0
-          ? args.confirmedSpaceIds
-          : preview.deletable.map((item) => item.spaceId);
-      const { targets, missingConfirmedSpaceIds } =
-        resolveConfirmedSpaceDeletionTargets(preview, confirmedIds);
-
-      const deletedSpaceIds: string[] = [];
-      const deletedKeys: string[] = [];
-      const deletedRecords: Array<{ server: string; dbKey: string }> = [];
-      const failures: Array<{ server?: string; dbKey: string; status: number; detail: string }> = [];
-      for (const target of targets) {
-        const record = spaceRecordsById[target.spaceId];
-        if (!record) {
-          failures.push({
-            dbKey: createSpaceKey.space(target.spaceId),
-            status: 404,
-            detail: "space record disappeared before deletion",
-          });
-          continue;
-        }
-        if (deleteServers.length === 0) {
-          failures.push({
-            dbKey: createSpaceKey.space(target.spaceId),
-            status: 0,
-            detail: "no delete server configured",
-          });
-          continue;
-        }
-        const keys = [
-          ...spaceMemberKeysForDelete(currentUserId, target.spaceId, record),
-          createSpaceKey.space(target.spaceId),
-        ];
-        let targetFailed = false;
-        for (const server of deleteServers) {
-          for (const dbKey of keys) {
-            const result = await deps.deleteServerKey(thunkApi, server, dbKey);
-            if (!result.ok) {
-              targetFailed = true;
-              failures.push({ server, dbKey, status: result.status, detail: result.detail });
-            } else {
-              deletedKeys.push(dbKey);
-              deletedRecords.push({ server, dbKey });
-            }
-          }
-        }
-        if (targetFailed) continue;
-
-        await deps.deleteOwnedSpace(thunkApi, {
-          spaceId: target.spaceId,
-          strategy: "delete-space-only",
-        });
-        deletedSpaceIds.push(target.spaceId);
-      }
-
-      const displayData =
-        deletedSpaceIds.length > 0
-          ? `已删除 ${deletedSpaceIds.length} 个 Space：${deletedSpaceIds.join(", ")}。内容记录未被删除。`
-          : "没有删除任何 Space。";
-
-      return {
-        rawData: {
-          deletedSpaceIds,
-          deletedKeys,
-          deletedRecords,
-          deleteServers,
-          missingConfirmedSpaceIds,
-          skipped: preview.skipped,
-          failures,
-        },
-        displayData,
-      };
-    },
-  };
-}
-
-const defaultHandlers = createDeleteSpacesToolHandlers(defaultDeps);
-
-export const deleteSpacesPreviewFunc = defaultHandlers.preview;
-export const deleteSpacesFunc = defaultHandlers.execute;