task-manager-logic 0.1.0

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "task-manager-logic",
+  "version": "0.1.0",
+  "private": false,
+  "description": "任务管理实现：状态机、组聚合、任务树存储",
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "task-manager-contract": "0.1.0"
+  },
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.com"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './statusMachine.js';
+export * from './tree.js';
+export * from './stores.js';

package/src/statusMachine.ts

@@ -0,0 +1,43 @@
+/**
+ * 任务状态机（BP-1）：转移合法性 + started_at/ended_at 语义。
+ */
+import {
+  OPERATION_TARGET,
+  TASK_TRANSITIONS,
+  TERMINAL_STATUSES,
+  type TaskDTO,
+  type TaskOperation,
+  type TaskStatus,
+} from 'task-manager-contract';
+
+export class TaskTransitionError extends Error {
+  constructor(public taskId: string, public from: TaskStatus, public to: TaskStatus) {
+    super(`illegal task transition ${from} -> ${to} (task ${taskId})`);
+  }
+}
+
+export function canTransition(from: TaskStatus, to: TaskStatus): boolean {
+  return TASK_TRANSITIONS[from].includes(to);
+}
+
+export function isTerminal(status: TaskStatus): boolean {
+  return TERMINAL_STATUSES.has(status);
+}
+
+/** 应用一次人工操作；非法转移抛 TaskTransitionError。返回同一 task 对象（原地更新）。 */
+export function applyOperation(
+  task: TaskDTO,
+  operation: TaskOperation,
+  operatorAccount: string,
+  nowMs: number,
+): TaskDTO {
+  const to = OPERATION_TARGET[operation];
+  if (!canTransition(task.status, to)) throw new TaskTransitionError(task.id, task.status, to);
+  const from = task.status;
+  task.status = to;
+  task.operatorAccount = operatorAccount;
+  if (to === 'Active' && from !== 'Active') task.startedAtMs ??= nowMs;
+  if (isTerminal(to)) task.endedAtMs = nowMs;
+  if (operation === 'delegate' || operation === 'forward') task.transferredBy = operatorAccount;
+  return task;
+}

package/src/stores.ts

@@ -0,0 +1,42 @@
+/**
+ * 任务树外置存储：内存 + 文件（JSON）。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import type { TaskSpaceDTO, TaskSpaceStore } from 'task-manager-contract';
+
+export class InMemoryTaskSpaceStore implements TaskSpaceStore {
+  private spaces = new Map<string, TaskSpaceDTO>();
+  async load(spaceId: string): Promise<TaskSpaceDTO | undefined> {
+    const s = this.spaces.get(spaceId);
+    return s ? structuredClone(s) : undefined;
+  }
+  async save(spaceId: string, space: TaskSpaceDTO): Promise<void> {
+    this.spaces.set(spaceId, structuredClone(space));
+  }
+  async remove(spaceId: string): Promise<void> {
+    this.spaces.delete(spaceId);
+  }
+}
+
+export class FileTaskSpaceStore implements TaskSpaceStore {
+  constructor(private dir: string) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  private file(spaceId: string) {
+    return path.join(this.dir, `${encodeURIComponent(spaceId)}.task-space.json`);
+  }
+  async load(spaceId: string): Promise<TaskSpaceDTO | undefined> {
+    const f = this.file(spaceId);
+    if (!fs.existsSync(f)) return undefined;
+    return JSON.parse(fs.readFileSync(f, 'utf8')) as TaskSpaceDTO;
+  }
+  async save(spaceId: string, space: TaskSpaceDTO): Promise<void> {
+    const f = this.file(spaceId);
+    fs.writeFileSync(f + '.tmp', JSON.stringify(space, null, 2));
+    fs.renameSync(f + '.tmp', f);
+  }
+  async remove(spaceId: string): Promise<void> {
+    fs.rmSync(this.file(spaceId), { force: true });
+  }
+}

package/src/tree.ts

@@ -0,0 +1,100 @@
+/**
+ * 任务树查找与组聚合（executionMode 语义，BP-2/BP-4）。
+ */
+import type { ExecutionMode, TaskDTO, TaskGroupDTO, TaskSpaceDTO, TaskStatus, TaskTreeNode } from 'task-manager-contract';
+import { isTerminal } from './statusMachine.js';
+
+export function findNode(space: TaskSpaceDTO, id: string): TaskTreeNode | undefined {
+  const walk = (nodes: TaskTreeNode[]): TaskTreeNode | undefined => {
+    for (const n of nodes) {
+      if (n.id === id) return n;
+      if (n.kind === 'group') {
+        const hit = walk(n.children);
+        if (hit) return hit;
+      }
+    }
+    return undefined;
+  };
+  return walk(space.children);
+}
+
+export function findTask(space: TaskSpaceDTO, id: string): TaskDTO | undefined {
+  const n = findNode(space, id);
+  return n?.kind === 'task' ? n : undefined;
+}
+
+export function listTasks(space: TaskSpaceDTO): TaskDTO[] {
+  const out: TaskDTO[] = [];
+  const walk = (nodes: TaskTreeNode[]) => {
+    for (const n of nodes) (n.kind === 'task' ? out.push(n) : walk(n.children));
+  };
+  walk(space.children);
+  return out;
+}
+
+/** 直接子节点 id 集合（TaskStep 只能绑定它们，BP-2） */
+export function directChildIds(space: TaskSpaceDTO): Set<string> {
+  return new Set(space.children.map((c) => c.id));
+}
+
+/**
+ * 节点终态判定：Task 用自身状态；Group 按 executionMode 聚合。
+ * 返回 undefined 表示尚未终态。
+ * - SEQUENTIAL / ALL：全部子节点终态才终态；全 DONE（FORWARDED 视同 DONE）→ DONE，否则 REFUSED。
+ * - ANY：任一 DONE/FORWARDED → DONE；全部终态且无 DONE → REFUSED。
+ */
+export function terminalStatusOf(node: TaskTreeNode): TaskStatus | undefined {
+  if (node.kind === 'task') return isTerminal(node.status) ? node.status : undefined;
+  return aggregateGroup(node);
+}
+
+const doneLike = (s: TaskStatus) => s === 'Done' || s === 'Forwarded';
+
+function aggregateGroup(group: TaskGroupDTO): TaskStatus | undefined {
+  const childStatuses = group.children.map((c) => terminalStatusOf(c));
+  const mode: ExecutionMode = group.executionMode;
+  if (mode === 'ANY') {
+    if (childStatuses.some((s) => s !== undefined && doneLike(s))) return 'Done';
+    if (childStatuses.every((s) => s !== undefined)) return 'Refused';
+    return undefined;
+  }
+  // SEQUENTIAL / ALL
+  if (childStatuses.some((s) => s === undefined)) {
+    // 提前失败：任一 REFUSED/ABANDONED 即整体 REFUSED（不必等其余）
+    if (childStatuses.some((s) => s !== undefined && !doneLike(s))) return 'Refused';
+    return undefined;
+  }
+  return childStatuses.every((s) => doneLike(s!)) ? 'Done' : 'Refused';
+}
+
+/** SEQUENTIAL 组内可操作性：前序兄弟（按 order）必须 done-like */
+export function isOperable(space: TaskSpaceDTO, taskId: string): boolean {
+  const check = (nodes: TaskTreeNode[], mode: ExecutionMode | null): boolean => {
+    const sorted = [...nodes].sort((a, b) => a.order - b.order);
+    for (let i = 0; i < sorted.length; i++) {
+      const n = sorted[i];
+      if (n.id === taskId || (n.kind === 'group' && findInGroup(n, taskId))) {
+        if (mode === 'SEQUENTIAL') {
+          for (let j = 0; j < i; j++) {
+            const prev = terminalStatusOf(sorted[j]);
+            if (prev === undefined || !doneLike(prev)) return false;
+          }
+        }
+        return n.id === taskId ? true : check((n as TaskGroupDTO).children, (n as TaskGroupDTO).executionMode);
+      }
+    }
+    return false;
+  };
+  const findInGroup = (g: TaskGroupDTO, id: string): boolean => !!findNodeIn(g.children, id);
+  const findNodeIn = (nodes: TaskTreeNode[], id: string): TaskTreeNode | undefined => {
+    for (const n of nodes) {
+      if (n.id === id) return n;
+      if (n.kind === 'group') {
+        const hit = findNodeIn(n.children, id);
+        if (hit) return hit;
+      }
+    }
+    return undefined;
+  };
+  return check(space.children, null);
+}