@umudik/task-bridge 0.0.1

package/apps/backend/dist/services/task-queue.js

@@ -0,0 +1,105 @@
+import { canonicalDescription, isTaskClaimed } from "../domain/task.js";
+import { resolveWorkStatus } from "../domain/work-status.js";
+import { emptyToNull } from "../lib/strings.js";
+import { getProjectById } from "./project-registry.js";
+import { buildEpicClaimIndex, canActorClaimTask, isWorkflowClaimable, normalizeClaimActor, sortWorkflowClaimCandidates, userAwaitingReply, workflowClaimBlockReason, } from "./task-claim-policy.js";
+import { claimBridgeTask, listBridgeTasks } from "./task-service.js";
+export { userAwaitingReply } from "./task-claim-policy.js";
+export function turnIdForTask(task) {
+    if (userAwaitingReply(task)) {
+        for (let index = task.comments.length - 1; index >= 0; index -= 1) {
+            const comment = task.comments[index];
+            if (!comment) {
+                continue;
+            }
+            if (comment.role === "user")
+                return `user-${comment.id}`;
+        }
+    }
+    if (isTaskClaimed(task) && task.claimedAt)
+        return `claimed-${task.claimedAt}`;
+    return `create-${task.createdAt}`;
+}
+function resolveWorkspacePath(task) {
+    const project = getProjectById(task.projectId);
+    if (project === null)
+        return null;
+    return emptyToNull(project.repoPath);
+}
+function buildClaimPayload(task, turnId) {
+    let workStatus;
+    if (task.parentId !== null) {
+        workStatus = resolveWorkStatus(task);
+    }
+    else {
+        workStatus = null;
+    }
+    return {
+        taskId: task.id,
+        turnId,
+        projectId: task.projectId,
+        projectName: task.projectName,
+        parentId: task.parentId,
+        epicId: task.epicId,
+        title: task.title,
+        description: canonicalDescription(task),
+        workspacePath: resolveWorkspacePath(task),
+        stageId: task.stageId,
+        workStatus,
+        createdAt: task.createdAt,
+        comments: task.comments,
+    };
+}
+function scopeTasks(tasks, projectId) {
+    if (!projectId)
+        return tasks;
+    return tasks.filter((task) => task.projectId === projectId);
+}
+export function listPendingTasks(projectId = null, rawActor = null) {
+    let actor;
+    if (rawActor !== null) {
+        actor = normalizeClaimActor(rawActor);
+    }
+    else {
+        actor = null;
+    }
+    const tasks = scopeTasks(listBridgeTasks(), projectId);
+    const index = buildEpicClaimIndex(tasks);
+    return sortWorkflowClaimCandidates(tasks.filter((task) => isWorkflowClaimable(task, index, actor)), index).map((task) => buildClaimPayload(task, turnIdForTask(task)));
+}
+export function claimNextTask(rawActor, options = null) {
+    const actor = normalizeClaimActor(rawActor);
+    let projectId;
+    if (options !== null) {
+        projectId = options.projectId;
+    }
+    else {
+        projectId = null;
+    }
+    const tasks = scopeTasks(listBridgeTasks(), projectId);
+    const index = buildEpicClaimIndex(tasks);
+    const candidates = sortWorkflowClaimCandidates(tasks.filter((task) => canActorClaimTask(task, index, actor)), index);
+    for (const candidate of candidates) {
+        const claimed = claimBridgeTask(candidate.id, actor.claimedBy);
+        if (!claimed)
+            continue;
+        return {
+            task: claimed,
+            item: buildClaimPayload(claimed, turnIdForTask(claimed)),
+        };
+    }
+    return null;
+}
+export function validateTaskClaim(taskId, rawActor) {
+    const actor = normalizeClaimActor(rawActor);
+    const tasks = listBridgeTasks();
+    const task = tasks.find((entry) => entry.id === taskId);
+    if (!task)
+        return "Task not found";
+    const index = buildEpicClaimIndex(tasks);
+    if (canActorClaimTask(task, index, actor))
+        return null;
+    if (isTaskClaimed(task) && !userAwaitingReply(task))
+        return "Task is already claimed";
+    return workflowClaimBlockReason(task, index, actor);
+}

package/apps/backend/dist/services/task-service.js

@@ -0,0 +1,198 @@
+import { allocateTaskRowId, listTaskRows, mutateTaskRow, upsertTaskRow, } from "../db/tasks-db.js";
+import { isDoneStage, resolveEpicId, touchTask, } from "../domain/task.js";
+import { isWorkDone } from "../domain/work-status.js";
+import { emptyToNull } from "../lib/strings.js";
+import { resolveTaskAssignee } from "./task-assignee-service.js";
+import { syncTaskIntoWorkflowState } from "./workflow-state-service.js";
+export { assertCanCompleteTask, canonicalDescription, DONE_STAGE_ID, isDoneStage, isTaskClaimed, listSubtasks, sortTasks, } from "../domain/task.js";
+export function allocateTaskId() {
+    return allocateTaskRowId();
+}
+export function listBridgeTasks() {
+    return listTaskRows({ id: 0 });
+}
+export function getBridgeTask(id) {
+    const rows = listTaskRows({ id });
+    if (rows.length === 0)
+        return null;
+    const row = rows[0];
+    if (!row)
+        return null;
+    return row;
+}
+export function upsertBridgeTask(input) {
+    const existingRows = listTaskRows({ id: input.id });
+    if (existingRows.length > 0) {
+        const existing = existingRows[0];
+        if (!existing)
+            throw new Error("Unexpected missing row");
+        existing.title = input.title;
+        existing.description = input.description;
+        existing.projectId = input.projectId;
+        existing.projectName = input.projectName;
+        touchTask(existing);
+        upsertTaskRow(existing);
+        return existing;
+    }
+    let createdAt = new Date().toISOString();
+    if (input.createdAt !== null) {
+        createdAt = input.createdAt;
+    }
+    let createdBy = "mobile";
+    if (input.createdBy !== null) {
+        createdBy = input.createdBy;
+    }
+    const existingTasks = listTaskRows({ id: 0 });
+    let parentRow = null;
+    if (input.parentId !== null) {
+        const parentRows = listTaskRows({ id: input.parentId });
+        if (parentRows.length > 0 && parentRows[0]) {
+            parentRow = parentRows[0];
+        }
+    }
+    let resolvedEpicId = null;
+    if (input.epicId !== null) {
+        resolvedEpicId = input.epicId;
+    }
+    else if (parentRow !== null) {
+        resolvedEpicId = resolveEpicId(existingTasks, parentRow);
+    }
+    let workStatus = null;
+    if (input.workStatus !== null) {
+        workStatus = input.workStatus;
+    }
+    else if (input.parentId !== null) {
+        workStatus = "todo";
+    }
+    const resolvedAssignee = resolveTaskAssignee({
+        projectId: input.projectId,
+        assignee: input.assignee,
+        assigneeRole: input.assigneeRole,
+        stageId: input.stageId,
+    });
+    const task = {
+        id: input.id,
+        projectId: input.projectId,
+        projectName: input.projectName,
+        parentId: input.parentId,
+        epicId: resolvedEpicId,
+        templateId: input.templateId,
+        title: input.title,
+        description: input.description,
+        acceptanceCriteria: null,
+        priority: null,
+        labels: [],
+        createdBy,
+        createdAt,
+        updatedAt: createdAt,
+        claimedBy: null,
+        claimedAt: null,
+        answeredBy: null,
+        answeredAt: null,
+        answer: null,
+        stageId: input.stageId,
+        workStatus,
+        assignee: resolvedAssignee.assignee,
+        assigneeRole: resolvedAssignee.assigneeRole,
+        assigneeKind: input.assigneeKind,
+        comments: [],
+        events: [{ type: "created", at: createdAt, by: createdBy, note: null }],
+    };
+    upsertTaskRow(task);
+    return task;
+}
+export function transitionBridgeTask(id, input) {
+    const existing = getBridgeTask(id);
+    if (!existing)
+        return null;
+    const resolved = resolveTaskAssignee({
+        projectId: existing.projectId,
+        assignee: input.assignee,
+        assigneeRole: existing.assigneeRole,
+        stageId: input.stageId,
+    });
+    return mutateTaskRow(id, (task) => {
+        const at = new Date().toISOString();
+        const fromStage = task.stageId;
+        task.stageId = input.stageId;
+        task.assignee = resolved.assignee;
+        if (resolved.assigneeRole) {
+            task.assigneeRole = resolved.assigneeRole;
+        }
+        if (isDoneStage(input.stageId)) {
+            task.claimedBy = null;
+            task.claimedAt = null;
+        }
+        task.events.push({
+            type: "stage_changed",
+            at,
+            by: input.by,
+            note: `${fromStage || "none"} -> ${input.stageId}`,
+        });
+        touchTask(task);
+    });
+}
+export function claimBridgeTask(id, claimedBy) {
+    const existingRows = listTaskRows({ id });
+    if (existingRows.length === 0)
+        return null;
+    const existing = existingRows[0];
+    if (!existing)
+        return null;
+    if (existing.claimedBy)
+        return null;
+    if (existing.parentId === null)
+        return null;
+    if (isWorkDone(existing))
+        return null;
+    return mutateTaskRow(id, (task) => {
+        const claimedAt = new Date().toISOString();
+        task.claimedBy = claimedBy;
+        task.claimedAt = claimedAt;
+        task.events.push({ type: "claimed", at: claimedAt, by: claimedBy, note: null });
+        touchTask(task);
+    });
+}
+export function releaseBridgeTask(id) {
+    return mutateTaskRow(id, (task) => {
+        task.claimedBy = null;
+        task.claimedAt = null;
+        touchTask(task);
+    });
+}
+export function updateBridgeTaskSpec(id, input) {
+    return mutateTaskRow(id, (task) => {
+        if (input.title !== null)
+            task.title = input.title;
+        if (input.description !== null) {
+            task.description = input.description;
+        }
+        const at = new Date().toISOString();
+        task.events.push({ type: "spec_updated", at, by: input.by, note: null });
+        touchTask(task);
+    });
+}
+export function addBridgeTaskUserComment(id, by, text) {
+    const body = emptyToNull(text);
+    if (!body)
+        return null;
+    const updated = mutateTaskRow(id, (task) => {
+        const at = new Date().toISOString();
+        task.comments.push({
+            id: `user-${id}-${Date.now()}`,
+            role: "user",
+            authorId: by,
+            tags: [],
+            body,
+            at,
+            metadata: null,
+        });
+        task.claimedBy = null;
+        task.claimedAt = null;
+        task.events.push({ type: "commented", at, by, note: body.slice(0, 200) });
+        touchTask(task);
+    });
+    if (updated)
+        syncTaskIntoWorkflowState(updated);
+    return updated;
+}

package/apps/backend/dist/services/workflow-rules.js

@@ -0,0 +1,18 @@
+import { incompleteSubtasks } from "../domain/task.js";
+import { AppError } from "../errors/app-error.js";
+import { listBridgeTasks } from "./task-service.js";
+export function validateStageTransition(task, stageId) {
+    if (stageId === task.stageId)
+        return;
+    const tasks = listBridgeTasks();
+    const blocked = incompleteSubtasks(tasks, task.id);
+    if (blocked.length === 0)
+        return;
+    throw new AppError(`Cannot move task: ${blocked.length} subtask(s) are not done`, 409, {
+        subtasks: blocked.map((entry) => ({
+            id: entry.id,
+            title: entry.title,
+            stageId: entry.stageId,
+        })),
+    });
+}