@longzai-intelligence-workflow/core 0.0.1 → 0.0.5

package/src/types/feed-event-trigger.ts

@@ -10,7 +10,7 @@ import type {
   feedEventNameSchema,
   feedEventPayloadSchema,
   feedEventTriggerSchema,
-} from '../schemas';
+} from '@/schemas';
 import type { z } from 'zod';
 
 /**

package/src/types/index.ts

@@ -1,6 +1,11 @@
 export * from './definition';
+
 export * from './instance';
+
 export * from './trigger';
+
 export * from './monitoring';
+
 export * from './feed-event-trigger';
+
 export * from './action-executor';

package/src/utils/dag.utils.ts

@@ -1,95 +1,16 @@
 /**
- * DAG 机件（环检测 + 拓扑分层 + 依赖满足判定）
- *
- * 共享基础（设计对齐 scheduler workflow 域已验证机件；真源归本包，禁止再镜像）。
+ * DAG 机件转发出口（真源 = @longzai-intelligence-dag/core 基础能力域；消费方零改动兼容）
  */
-
-/**
- * 依赖边（from 完成后 to 可启）
- */
-export type DependencyEdge = { readonly from: string; readonly to: string };
-
-/**
- * 环检测（DFS 三色标记；返回首个环路径，无环为 null）
- *
- * @param edges - 依赖边集合
- */
-export function detectCycle(edges: readonly DependencyEdge[]): readonly string[] | null {
-  /**
-   * 邻接表
-   */
-  const adjacency = new Map<string, string[]>();
-  for (const edge of edges) {
-    adjacency.set(edge.from, [...(adjacency.get(edge.from) ?? []), edge.to]);
-  }
-
-  /**
-   * 节点访问状态（0=未访问 1=在栈 2=完成）
-   */
-  const state = new Map<string, 0 | 1 | 2>();
-
-  /**
-   * 当前 DFS 路径
-   */
-  const path: string[] = [];
-
-  /**
-   * 单节点深搜（返回环路径或 null）
-   */
-  const visit = (node: string): readonly string[] | null => {
-    /**
-     * 当前节点状态
-     */
-    const current = state.get(node) ?? 0;
-    if (current === 1) {
-      /**
-       * 环路径：当前路径中该节点之后的部分 + 首尾相接
-       */
-      const start = path.indexOf(node);
-      return [...path.slice(start), node];
-    }
-    if (current === 2) {
-      return null;
-    }
-    state.set(node, 1);
-    path.push(node);
-    for (const next of adjacency.get(node) ?? []) {
-      /**
-       * 后继环路径
-       */
-      const cycle = visit(next);
-      if (cycle !== null) {
-        return cycle;
-      }
-    }
-    path.pop();
-    state.set(node, 2);
-    return null;
-  };
-
-  /**
-   * 全部节点（确定性排序）
-   */
-  const nodes = [...new Set(edges.flatMap((edge) => [edge.from, edge.to]))].sort((left, right) => (left < right ? -1 : 1));
-  for (const node of nodes) {
-    /**
-     * 各节点环检测
-     */
-    const cycle = visit(node);
-    if (cycle !== null) {
-      return cycle;
-    }
-  }
-  return null;
-}
-
-/**
- * 依赖满足判定（全部前置达完成/验收才算满足；无前置视为满足）
- *
- * @param node - 目标工作项 id
- * @param edges - 依赖边集合
- * @param settled - 已闭环（完成/验收）的工作项集合
- */
-export function dependenciesMet(node: string, edges: readonly DependencyEdge[], settled: ReadonlySet<string>): boolean {
-  return edges.filter((edge) => edge.to === node).every((edge) => settled.has(edge.from));
-}
+export {
+  type DependencyEdge,
+  detectCycle,
+  detectCycles,
+  dependenciesMet,
+  areAllDependenciesMet,
+  downstreamOf,
+  nodesOf,
+  topologicalLevels,
+  topologicalSort,
+  validateEdges,
+  type EdgeIssue,
+} from '@longzai-intelligence-dag/core';

package/src/utils/index.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE } from '../constants/workflow';
+import { DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE } from '@/constants/workflow';
 
 export function getPagination(page?: number, pageSize?: number): { offset: number; limit: number } {
   const limit = Math.min(pageSize ?? DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE);
@@ -15,5 +15,7 @@ export function formatDate(date: string | Date): string {
 }
 
 export * from './declaration-frontmatter.utils';
-export * from './dag.utils';
+
 export * from './work-item-rules.utils';
+
+export * from './dag.utils';

package/src/utils/work-item-rules.utils.ts

@@ -1,15 +1,24 @@
+import type {
+  WorkflowEdge,
+  WorkflowGate,
+  WorkflowItem,
+  WorkItemStatus,
+} from '@/schemas/workflow-doc.schema';
+
 /**
  * 工作项判定核（纯函数、零 I/O——输入声明形态，输出视图与违规）
  *
  * 判定器契约：只判不动（对齐家族 verify 模式）；执行状态归声明档由属主维护，
  * 本模块不做任何状态写入，仅依据声明现状派生视图与转移合法性。
  */
-import type { WorkflowEdge, WorkflowGate, WorkflowItem, WorkItemStatus } from '../schemas/workflow-doc.schema';
+import { dependenciesMet } from '@longzai-intelligence-dag/core';
 
 /**
  * 工作项合法状态转移表（状态机唯一注册点；供编辑工具与判定器共用的规则真源）
  */
-export const ALLOWED_STATUS_TRANSITIONS: Readonly<Record<WorkItemStatus, readonly WorkItemStatus[]>> = {
+export const ALLOWED_STATUS_TRANSITIONS: Readonly<
+  Record<WorkItemStatus, readonly WorkItemStatus[]>
+> = {
   todo: ['doing', 'blocked', 'dropped'],
   doing: ['blocked', 'done', 'dropped'],
   blocked: ['todo', 'doing', 'dropped'],
@@ -39,7 +48,10 @@ export type InvalidTransitionError = {
  * @param to - 目标状态
  * @returns 合法时为 null；非法时携带合法后继清单
  */
-export function checkStatusTransition(from: WorkItemStatus, to: WorkItemStatus): InvalidTransitionError | null {
+export function checkStatusTransition(
+  from: WorkItemStatus,
+  to: WorkItemStatus,
+): InvalidTransitionError | null {
   /**
    * 注册表中的合法后继
    */
@@ -48,7 +60,10 @@ export function checkStatusTransition(from: WorkItemStatus, to: WorkItemStatus):
     return { code: 'INVALID_TRANSITION', message: `未知状态：${from}` };
   }
   if (!allowed.includes(to)) {
-    return { code: 'INVALID_TRANSITION', message: `非法转移：${from} → ${to}（合法后继：${allowed.join(' / ')}）` };
+    return {
+      code: 'INVALID_TRANSITION',
+      message: `非法转移：${from} → ${to}（合法后继：${allowed.join(' / ')}）`,
+    };
   }
   return null;
 }
@@ -132,6 +147,7 @@ export type WorkflowView = {
  * 已闭环状态集合（依赖满足判定基准：done 或 dropped 均不再阻塞后继）
  *
  * @param status - 工作项状态
+ * @returns 状态为 done 或 dropped 时为 true，否则为 false
  */
 function isSettled(status: WorkItemStatus): boolean {
   return status === 'done' || status === 'dropped';
@@ -143,6 +159,7 @@ function isSettled(status: WorkItemStatus): boolean {
  * @param items - 工作项清单（声明档现状）
  * @param edges - 依赖边清单
  * @param gates - 裁定门清单（含裁定事实）
+ * @returns 工作流声明视图，含全部工作项视图与未决裁定清单
  */
 export function deriveWorkflowView(
   items: readonly WorkflowItem[],
@@ -157,16 +174,20 @@ export function deriveWorkflowView(
   /**
    * 各工作项挂靠的未批准门（ruling.status 非 approved 即阻塞）
    */
-  const unapprovedGateAt = new Set(gates.filter((gate) => gate.ruling.status !== 'approved' && gate.at !== 'workflow').map((gate) => gate.at));
+  const unapprovedGateAt = new Set(
+    gates
+      .filter((gate) => gate.ruling.status !== 'approved' && gate.at !== 'workflow')
+      .map((gate) => gate.at),
+  );
 
   /**
    * 工作项视图累积
    */
   const views: WorkItemView[] = items.map((item) => {
     /**
-     * 依赖满足判定（全部前置闭环）
+     * 依赖满足判定（DAG 基础能力域机件，闭环定义由本域注入）
      */
-    const depsMet = edges.filter((edge) => edge.to === item.id).every((edge) => settled.has(edge.from));
+    const depsMet = dependenciesMet(item.id, edges, settled);
 
     return {
       id: item.id,