@xtalpi/agentic-lab-skills 0.0.1

package/skills/lab-flow-designer/embedded-template/scripts//347/244/272/344/276/213/346/225/260/346/215/256/344/270/216/346/240/241/351/252/214/351/227/250/346/216/247.js

@@ -0,0 +1,149 @@
+/**
+ * 示例门控脚本：结构对齐本 skill 主 SKILL.md 与 embedded-template；API 对齐 references/agentic-lab-sdk.md
+ * 输入输出类型对齐 references/agentic-lab-processer.md（参数与返回值均为 snake_case）。
+ * 业务规则以用户提供的流程说明 Markdown 为准（「数据查询方式」「字段映射」「数据处理规则」等）。
+ *
+ * 门控执行顺序：前置处理(start) → 人工处理(页面) → 后置处理(complete)
+ *
+ * 列表类查询：流程说明未要求分页时，显式 limit/offset（见主 SKILL「门控脚本编写指引 → 分页与查全量」）。
+ *
+ * 类型安全：ticket.detail 值为任意 JSON 类型（string/number/null/array/object），
+ * 禁止直接调 .trim()/.split() 等 String 方法——须先 String() 转换（见「编写指引 §5」）。
+ */
+const DEFAULT_QUERY_LIMIT = 999999;
+
+// orbit_link 由流程文档门控脚本配置项中的 PageUrl 与门控前置处理中的 bookid 组合生成
+const PAGE_URL = 'http://10.249.133.129:9048/?view=book&book={bookid}';
+const BOOK_ID = '1';
+
+// --- 类型安全辅助函数（detail 值可为任意 JSON 类型，须先转换再操作）---
+function str(v) {
+  return v != null ? String(v) : '';
+}
+function num(v, fallback) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : (fallback !== undefined ? fallback : 0);
+}
+
+class Processer {
+  constructor(context) {
+    this.context = context;
+  }
+
+  // --- 前置处理 → start ---
+  // params: { valve_id, pool_ids }
+  // returns: { orbit_link, ticket_ids }
+  async start(params) {
+    const { valve_id, pool_ids } = params;
+    const { list: tickets } = await this.context.ticket.list({
+      pool_id__in: pool_ids,
+      limit: DEFAULT_QUERY_LIMIT,
+      offset: 0,
+    });
+
+    const compoundIdList = [
+      ...new Set(
+        tickets
+          .map((t) => t.detail?.cmpd_id || t.detail?.compound_id)
+          .filter(Boolean)
+      ),
+    ];
+
+    let chemicalRecords = [];
+    let stockRecords = [];
+    if (compoundIdList.length > 0) {
+      const filter = { cmpd_id: { $in: compoundIdList } };
+      chemicalRecords = await this.context.compound.getChemicalRecord({
+        filter,
+        limit: DEFAULT_QUERY_LIMIT,
+        offset: 0,
+      });
+      stockRecords = await this.context.compound.getStock({
+        filter,
+        limit: DEFAULT_QUERY_LIMIT,
+        offset: 0,
+      });
+    }
+
+    const stations = await this.context.station.list();
+    const processIds = tickets
+      .flatMap((t) => t.detail?.process_ids || [])
+      .filter(Boolean);
+    const processes =
+      processIds.length > 0
+        ? await this.context.process.list({
+            processIds,
+            limit: DEFAULT_QUERY_LIMIT,
+            offset: 0,
+          })
+        : [];
+
+    // --- 规则 1.1～1.4：按 valves/示例数据与校验门控.md「数据处理规则」写回 detail（以下为示意）---
+    for (const ticket of tickets) {
+      const d = ticket.detail || {};
+      const chem = chemicalRecords.find((r) => r.cmpd_id === d.cmpd_id);
+      const stock = stockRecords.filter((r) => r.cmpd_id === d.cmpd_id);
+
+      if (chem) {
+        d.chemist_property = str(chem.chemist_property);
+        d.dispensable = chem.dispensable;
+        d.dispensing_remark = str(chem.dispensing_remark);
+      }
+      if (stock.length) {
+        d.available_amount_mg = stock.reduce(
+          (s, r) => s + num(r.latest_amount_mg, 0),
+          0
+        );
+      }
+      d._stations_count = stations.length;
+      d._processes_preview = processes;
+      ticket.detail = d;
+    }
+
+    await this.context.ticket.update(tickets);
+
+    const orbit_link = PAGE_URL.replace('{bookid}', BOOK_ID);
+
+    return {
+      orbit_link,
+      ticket_ids: tickets.map((t) => t.id),
+    };
+  }
+
+  // --- 后置处理 → complete ---
+  // params: { valve_id, tickets }
+  // returns: { new_tickets }
+  async complete(params) {
+    const { valve_id, tickets } = params;
+
+    const nextPools = await this.context.pool.getNext(valve_id);
+    const outPool = nextPools.find((p) => p.name === '出口池');
+
+    if (!outPool) {
+      throw new Error(
+        `未找到出口池；nextPools=${nextPools.map((p) => p.name).join(',')}`
+      );
+    }
+
+    // 将入口池的tickets更新为”已完成”状态，避免重复处理
+    const finished = tickets.map((t) => ({
+      ...t,
+      status: 'finished',
+    }));
+    await this.context.ticket.update(finished);
+
+    // 按出口池 schema 映射为新 tickets，由引擎自动创建（不在脚本内调用 ticket.append）
+    const new_tickets = finished.map((t) => ({
+      flow_id: t.flow_id,
+      pool_id: outPool.id,
+      order_id: t.order_id,
+      detail: t.detail,
+      status: 'created',
+      parent_ticket_id: t.id,
+    }));
+
+    return {
+      new_tickets,
+    };
+  }
+}

package/skills/lab-flow-designer/embedded-template/valves//347/244/272/344/276/213/346/225/260/346/215/256/344/270/216/346/240/241/351/252/214/351/227/250/346/216/247.md

@@ -0,0 +1,100 @@
+# 示例数据与校验门控
+
+## 概述
+
+演示与真实 Fragment 门控相同的文档结构：**门控 YAML**、**化合物数据查询方式**、**字段映射**、**数据处理规则**、**start/complete 分工**。生成业务流程注册包时，按流程说明替换各节内容；脚本实现须对照 [references/agentic-lab-sdk.md](../../references/agentic-lab-sdk.md)。
+
+## 关联脚本
+
+**脚本路径**: [scripts/示例数据与校验门控.js](scripts/示例数据与校验门控.js)
+
+该脚本导出 `Processer` 类，实现 `start` 和 `complete` 方法。
+
+## 门控 YAML（与流程说明对齐）
+
+流程说明中可能使用 `Stash:` 等键表示目标池；生成脚本时以 **`pool.name`**（或文档中的池显示名称）与 `pool.getNext(valve_id)` 返回值匹配（`valve_id` 来自 `Processer` 入参）。
+
+```yaml
+valve_id: valve_example_1
+name: 示例数据与校验门控
+order: 1
+input:
+  primary: 入口池
+output:
+  - pool: 出口池
+    condition: 示例：校验通过且已回填必要字段
+```
+
+## 化合物数据查询方式（映射到 Agentic Lab SDK）
+
+| 流程说明中的表述 | 推荐 SDK 调用 |
+|----------------|---------------|
+| 查 compound 表 / 可用量 / 库存汇总 | `context.compound.getStock({ filter, limit, offset })`；`filter` 为 NocoBase 条件；**流程未写分页时**建议 `limit: 999999`、`offset: 0`（见主 `SKILL.md` 门控脚本指引）。另见 [agentic-lab-sdk](../../references/agentic-lab-sdk.md)、[Filter Operators](https://docs.nocobase.com/api/database/operators) |
+| 查 chemical_record / 知识库属性 | `context.compound.getChemicalRecord({ filter, limit, offset })`；同上，默认大 `limit` 防截断 |
+
+## 字段映射（示例：知识库 → ticket.detail）
+
+> **仅供结构演示**：下表中的加工数据名、库侧列名、`detail` 键仅为说明「表格长什么样、如何对齐 snake_case」，**不**绑定任何具体业务；其它流程须整表替换为用户流程说明中的映射。
+
+流程说明中的「门控加工数据 ↔ 库字段」表，在脚本里写入 `ticket.detail` 时建议与 **pools Schema 的「字段」列（snake_case）** 对齐。以下为示意（真实以流程文档表格为准）：
+
+| 门控加工数据 | chemical_record（示例列名） | detail 键（示例） |
+|-------------|------------------------------|------------------|
+| 性状(Chemist) | chemistProperty | chemist_property |
+| 可分装判断 | dispensable | dispensable |
+| 可舀粉判断 | feasibilityOfDipensing | feasibility_of_dipensing |
+
+（真实流程以用户提供的流程说明 Markdown 中表格为准。）
+
+## 数据处理规则（脚本注释应对齐序号）
+
+> **同上**：`1.1` 等序号格式应对齐流程文档；下列规则摘要与动作为**占位示意**（偏分装场景），生成其它业务包时须按流程说明中的规则表重写。
+
+| 序号 | 规则摘要 | 业务动作（示意） |
+|------|----------|------------------|
+| 1.1 | 汇总需求量 | `detail.requested_amount = sum(target_amount_n)` |
+| 1.2 | 缺料判定 | 结合 `getStock` 汇总可用量与 `requested_amount` 比较 |
+| 1.3 | 容差默认 | 目标量 >0 且容差空 → 默认 0.5 mg |
+| 1.4 | 缺料标记 | `source_barcode` 空 → `是否缺料` = 缺料 |
+
+## 执行流程
+
+**门控执行顺序：前置处理（脚本 `start`）→ 人工处理（页面）→ 后置处理（脚本 `complete`）**
+
+### 前置处理
+
+| 配置项 | 类别 | 默认值 / 占位 | 说明 |
+| ------ | ---- | -------------- | ---- |
+| bookid | 参数 | 1 | Orbit 页面对应的 BookId，用于拼装 `orbit_link` |
+
+| 规则摘要 | 条件要点 | 业务动作或结果 |
+| -------- | -------- | -------------- |
+| 查询入口池 | 门控启动 | `ticket.list({ pool_id__in: pool_ids, limit: 999999, offset: 0 })`，取返回体 `list` |
+| 查化合物数据 | 有 compound 查询需求 | `compound.getChemicalRecord` / `compound.getStock`（同上默认大 `limit`） |
+| 写回 detail | 查询完成 | 按映射表与规则表写回 `ticket.detail` → `ticket.update` |
+| 拼装 orbit_link | 返回前 | `PageUrl.replace('{bookid}', bookid)` |
+
+**start 返回**：`{ orbit_link, ticket_ids }`
+
+### 人工处理
+
+##### 界面形态与数据绑定
+
+1. **界面类型**：超级表格
+2. **数据来源**：前置处理写入 `ticket.detail` 的字段
+3. **操作按钮**：刷新 / 检查 / 提交（由 `studio-orbit-vue-component` 技能生成 UI）
+
+### 后置处理
+
+| 规则摘要 | 条件要点 | 业务动作或结果 |
+| -------- | -------- | -------------- |
+| 获取出口池 | `pool.getNext(valve_id)` | 按 `pool.name` 匹配出口池 |
+| 更新入口池状态 | 出口池确定 | 入口池 tickets 更新为 `status: 'finished'` → `ticket.update` |
+| 映射出口池记录 | 状态更新完成 | 按出口池 Schema 构建 `new_tickets`（含 `flow_id`、`pool_id`、`order_id`、`detail`、`status: 'created'`、`parent_ticket_id`） |
+
+**complete 返回**：`{ new_tickets }`（由引擎自动创建，脚本不调用 `ticket.append`）
+
+## 输入/输出
+
+- **输入池**: 入口池
+- **输出池**: 出口池（多出口时与 YAML 中各 `pool`/`Stash` 目标池名称一致）

package/skills/lab-flow-designer/references/agentic-lab-processer.md

@@ -0,0 +1,101 @@
+> Agentic Lab 门控脚本
+
+### 类型定义
+
+#### start
+
+```typescript
+interface StartExecutionParams {
+  valve_id: number;
+  pool_ids: number[];
+  [propName: string]: any;
+}
+
+interface StartExecutionResult {
+  orbit_link: string;
+  ticket_ids: number[];
+  [propName: string]: any;
+}
+
+async start(params: StartExecutionParams): Promise<StartExecutionResult>
+```
+
+#### complete
+
+```typescript
+interface CompleteExecutionParams {
+  valve_id: number;
+  tickets: Record<string, any>[];
+  [propName: string]: any;
+}
+
+interface CompleteExecutionResult {
+ new_tickets?: Record<string, any>[]; // 待新增的tickets，由引擎创建到数据表
+ [propName: string]: any;
+}
+
+async complete(params: CompleteExecutionParams): Promise<CompleteExecutionResult>
+```
+
+
+### 示例
+
+```javascript
+class Processer {
+  // context: 执行引擎提供的SDK
+  constructor(context) {
+    this.context = context;
+  }
+
+  // params: { valve_id, pool_ids }
+  async start(params) {
+    const tickets = await this.context.ticket.list({ pool_id__in: pool_ids });
+    const stations = await this.context.station.list();
+    
+    const process_ids = []; // 从tickets detail 按需提取出process ids
+    const processes = await this.context.process.list({ process_ids });
+
+    // 基于stations、processes等数据源，筛选待处理tickets
+    const finalTickets = tickets.filter(ticket => ticket);
+
+    // 将processes更新到finalTickets detail中
+    finalTickets.forEach(ticket => { ticket.detail.processes = processes })
+    // 更新数据库中的tickets，以便Orbit视图获取最新数据
+    await this.context.ticket.update(finalTickets)
+    
+    return {
+      orbit_link: 'https://orbit-sh.xtalpi.xyz/?view=book&book=3947',
+      ticket_ids: finalTickets.map(ticket => ticket.id),
+    }
+  }
+
+  // params: { valve_id, tickets }
+  async complete(params) {
+    // params.tickets 已包含本次待处理的人工录入数据，通常无需重新查询；如需补充数据库数据请按实际需求调用查询方法
+
+    // 获取当前门控的（一个或多个）出口池
+    const nextPools = this.context.pool.getNext(valveId);
+    const successPool = nextPools.find(pool => pool.name === 'xxx成功');
+    const failedPool = nextPools.find(pool => pool.name === 'xxx失败');
+
+    // 基于实时tickets，按实际业务场景(流程说明书中的相关定义)，筛选出“可流入出口池”的tickets
+    const finalTickets = params.tickets.filter(ticket => ticket).map(t => ({ ...t, status: 'finished' }));
+
+    // 将入口池的tickets更新为“已完成”状态，避免重复处理
+    await this.context.ticket.update(finalTickets);
+
+    // 按实际的业务场景(流程说明书中的相关定义)， 筛选出“可流入成功出口池”的tickets，并按出口池的schema 映射为新的tickets
+    const newSuccessTickets = finalTickets.filter(ticket => ticket).map(t => ({ ...t, status: 'created', pool_id: successPool.id }));
+    // 按实际的业务场景(流程说明书中的相关定义)， 筛选出“可流入失败出口池”的tickets，并按出口池的schema 映射为新的tickets
+    const newFailedTickets = finalTickets.filter(ticket => ticket).map(t => ({ ...t, status: 'created', pool_id: failedPool.id }));
+
+    // 脚本不负责创建新ticket，交由引擎自动创建（需返回new_tickets）
+    return {
+      new_tickets: [
+        ...newSuccessTickets,
+        ...newFailedTickets
+      ]
+    }
+  }
+}
+```