@umudik/task-bridge 0.0.1

package/apps/backend/dist/services/workflow-state-service.js

@@ -0,0 +1,157 @@
+import { buildInitialWorkflowState, summarizeWorkflowStateNodes, } from "../domain/workflow-state.js";
+import { getEpicWorkflowStateData, insertEpicRow, insertWorkflowStateRow, mutateEpicWorkflowState, saveEpicWorkflowStateData, updateEpicStageRow, } from "../db/epic-workflow-db.js";
+import { listWorkflowStageRows } from "../db/workflow-db.js";
+import { resolveWorkStatus } from "../domain/work-status.js";
+export function rebuildEpicWorkflowState(epicId, projectId, stageId) {
+    const stageRows = listWorkflowStageRows({ projectId, stageId: "" });
+    const initial = buildInitialWorkflowState({
+        stageId,
+        stages: stageRows.map((row) => ({
+            id: row.id,
+            taskTemplatesJson: row.task_templates_json,
+            title: row.title,
+        })),
+    });
+    updateEpicStageRow(epicId, stageId);
+    return saveEpicWorkflowStateData(epicId, initial);
+}
+export function rollbackEpicWorkflowFromStage(epicId, sourceStageId, projectId) {
+    const stageRows = listWorkflowStageRows({ projectId, stageId: "" });
+    const ordered = stageRows.slice().sort((a, b) => a.position - b.position);
+    const stageIndex = ordered.findIndex((row) => row.id === sourceStageId);
+    let laterStageIds;
+    if (stageIndex < 0) {
+        laterStageIds = new Set();
+    }
+    else {
+        laterStageIds = new Set(ordered.slice(stageIndex + 1).map((row) => row.id));
+    }
+    updateEpicStageRow(epicId, sourceStageId);
+    mutateEpicWorkflowState(epicId, (data) => {
+        data.stageId = sourceStageId;
+        for (const node of Object.values(data.nodes)) {
+            if (!laterStageIds.has(node.stageId))
+                continue;
+            node.taskId = null;
+            node.workStatus = "todo";
+            node.comments = [];
+        }
+    });
+}
+export function resetWorkflowStateNodesForTasks(epicId, taskIds) {
+    if (taskIds.size === 0)
+        return;
+    mutateEpicWorkflowState(epicId, (data) => {
+        for (const node of Object.values(data.nodes)) {
+            if (node.taskId !== null && taskIds.has(node.taskId)) {
+                node.workStatus = "todo";
+            }
+        }
+    });
+}
+export function createEpicRecords(input) {
+    insertEpicRow({
+        id: input.id,
+        projectId: input.projectId,
+        title: input.title,
+        description: input.description,
+        stageId: input.stageId,
+        createdBy: input.createdBy,
+    });
+    const stageRows = listWorkflowStageRows({ projectId: input.projectId, stageId: "" });
+    const initial = buildInitialWorkflowState({
+        stageId: input.stageId,
+        stages: stageRows.map((row) => ({
+            id: row.id,
+            taskTemplatesJson: row.task_templates_json,
+            title: row.title,
+        })),
+    });
+    insertWorkflowStateRow(input.id, initial);
+    return initial;
+}
+export function loadEpicWorkflowState(epicId) {
+    return getEpicWorkflowStateData(epicId);
+}
+export function syncEpicWorkflowStage(epicId, stageId) {
+    updateEpicStageRow(epicId, stageId);
+    mutateEpicWorkflowState(epicId, (data) => {
+        data.stageId = stageId;
+    });
+}
+export function linkSpawnedTemplateTask(epicId, templateId, taskId) {
+    mutateEpicWorkflowState(epicId, (data) => {
+        const node = data.nodes[templateId];
+        if (!node)
+            return;
+        node.taskId = taskId;
+    });
+}
+export function syncTaskIntoWorkflowState(task) {
+    const epicId = task.epicId;
+    const templateId = task.templateId;
+    if (epicId === null || templateId === null)
+        return;
+    mutateEpicWorkflowState(epicId, (data) => {
+        const node = data.nodes[templateId];
+        if (!node)
+            return;
+        node.taskId = task.id;
+        node.workStatus = resolveWorkStatus(task);
+        node.comments = task.comments.slice();
+        node.title = task.title;
+        node.description = task.description;
+    });
+}
+export function readWorkflowStateNode(epicId, templateId) {
+    const data = getEpicWorkflowStateData(epicId);
+    if (!data)
+        return null;
+    const node = data.nodes[templateId];
+    if (node) {
+        return node;
+    }
+    return null;
+}
+export function patchWorkflowStateNode(epicId, templateId, patch, apply) {
+    mutateEpicWorkflowState(epicId, (data) => {
+        const node = data.nodes[templateId];
+        if (!node)
+            return;
+        if (apply.workStatus && patch.workStatus !== null) {
+            node.workStatus = patch.workStatus;
+        }
+        if (apply.comments && patch.comments !== null) {
+            node.comments = patch.comments.slice();
+        }
+        if (apply.taskId) {
+            node.taskId = patch.taskId;
+        }
+    });
+}
+export function listWorkflowStateSummaries(epicId) {
+    const data = getEpicWorkflowStateData(epicId);
+    if (!data)
+        return [];
+    return summarizeWorkflowStateNodes(data);
+}
+export function spawnContextFromWorkflowState(data) {
+    const spawnedTemplateIds = new Set();
+    const doneTemplateIds = new Set();
+    for (const node of Object.values(data.nodes)) {
+        if (node.taskId !== null)
+            spawnedTemplateIds.add(node.templateId);
+        if (node.workStatus === "done")
+            doneTemplateIds.add(node.templateId);
+    }
+    return { spawnedTemplateIds, doneTemplateIds };
+}
+export function applyWorkflowStateNodeToTaskInput(epicId, templateId, defaults) {
+    const node = readWorkflowStateNode(epicId, templateId);
+    if (!node)
+        return defaults;
+    return {
+        workStatus: node.workStatus,
+        comments: node.comments.slice(),
+    };
+}

package/apps/backend/dist/services/workflow-template-service.js

@@ -0,0 +1,204 @@
+import { deleteWorkflowStagesForProject, insertWorkflowStageRow, } from "../db/workflow-db.js";
+import { randomUUID } from "node:crypto";
+import { deleteWorkflowTemplateRow, deleteWorkflowTemplateStages, insertWorkflowTemplateRow, insertWorkflowTemplateStageRow, listWorkflowTemplateRows, listWorkflowTemplateStageRows, seedDefaultWorkflowTemplates, } from "../db/workflow-template-db.js";
+import { resolveEpicDescription, resolveStageTaskTemplates, serializeTaskTemplates, } from "../domain/workflow-stage.js";
+import { DEFAULT_WORKFLOW_TEMPLATE_ID } from "../domain/workflow-template-id.js";
+import { AppError } from "../errors/app-error.js";
+import { valueOrEmpty } from "../lib/strings.js";
+function layoutCoord(value) {
+    return value;
+}
+function templateStageRowToStage(row) {
+    const taskTemplates = resolveStageTaskTemplates({
+        taskTemplatesJson: row.task_templates_json,
+        stageId: row.id,
+        stageTitle: row.title,
+    });
+    return {
+        id: row.id,
+        title: row.title,
+        description: resolveEpicDescription({
+            description: row.description,
+            purpose: row.purpose,
+            rulesJson: row.rules_json,
+        }),
+        position: row.position,
+        autoAssignRole: null,
+        layoutX: layoutCoord(row.layout_x),
+        layoutY: layoutCoord(row.layout_y),
+        spawnTaskCount: taskTemplates.length,
+        taskTemplates,
+        activeTaskCount: null,
+    };
+}
+function slugify(value) {
+    return value
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function defaultTemplateStage() {
+    return {
+        id: `stage-${randomUUID()}`,
+        title: "New epic",
+        description: "",
+        position: 0,
+        autoAssignRole: null,
+        layoutX: null,
+        layoutY: null,
+        spawnTaskCount: 0,
+        taskTemplates: [],
+        activeTaskCount: null,
+    };
+}
+function resolveTemplateIdHint(id) {
+    if (id === null) {
+        return "";
+    }
+    return id;
+}
+function stagePosition(stage, index) {
+    if (Number.isFinite(stage.position)) {
+        return stage.position;
+    }
+    return index;
+}
+export function ensureDefaultWorkflowTemplates() {
+    seedDefaultWorkflowTemplates();
+}
+export function createWorkflowTemplate(input) {
+    ensureDefaultWorkflowTemplates();
+    const title = input.title;
+    if (!title) {
+        throw new AppError("Title is required", 400);
+    }
+    const idHint = resolveTemplateIdHint(input.id);
+    const baseId = idHint || slugify(title) || `template-${randomUUID().slice(0, 8)}`;
+    let id = baseId;
+    let suffix = 2;
+    while (listWorkflowTemplateRows({ id }).length > 0) {
+        id = `${baseId}-${suffix}`;
+        suffix += 1;
+    }
+    insertWorkflowTemplateRow({
+        id,
+        title,
+        description: valueOrEmpty(input.description),
+    });
+    return replaceWorkflowTemplate(id, [defaultTemplateStage()]);
+}
+export function listWorkflowTemplates() {
+    ensureDefaultWorkflowTemplates();
+    return listWorkflowTemplateRows({ id: "" }).map((row) => ({
+        id: row.id,
+        title: row.title,
+        description: row.description,
+    }));
+}
+export function getWorkflowTemplate(templateId) {
+    ensureDefaultWorkflowTemplates();
+    const id = templateId;
+    const rows = listWorkflowTemplateRows({ id });
+    if (rows.length === 0) {
+        return null;
+    }
+    const row = rows[0];
+    if (!row)
+        return null;
+    const stages = listWorkflowTemplateStageRows(id).map(templateStageRowToStage);
+    return {
+        id: row.id,
+        title: row.title,
+        description: row.description,
+        stages,
+    };
+}
+export function replaceWorkflowTemplate(templateId, stages) {
+    ensureDefaultWorkflowTemplates();
+    const id = templateId;
+    const templateRows = listWorkflowTemplateRows({ id });
+    if (templateRows.length === 0) {
+        throw new AppError("Workflow template not found", 404);
+    }
+    const row = templateRows[0];
+    if (!row)
+        throw new AppError("Workflow template not found", 404);
+    deleteWorkflowTemplateStages(id);
+    stages.forEach((stage, index) => {
+        insertWorkflowTemplateStageRow({
+            templateId: id,
+            id: stage.id,
+            title: stage.title,
+            description: stage.description,
+            purpose: "",
+            rulesJson: "[]",
+            position: stagePosition(stage, index),
+            autoAssign: false,
+            layoutX: stage.layoutX,
+            layoutY: stage.layoutY,
+            spawnTaskCount: stage.taskTemplates.length,
+            taskTemplatesJson: serializeTaskTemplates(stage.taskTemplates),
+        });
+    });
+    const updated = getWorkflowTemplate(id);
+    if (!updated) {
+        throw new AppError("Workflow template not found", 404);
+    }
+    return updated;
+}
+export function importWorkflowTemplate(input) {
+    ensureDefaultWorkflowTemplates();
+    const title = input.title;
+    if (!title)
+        throw new AppError("Title is required", 400);
+    const idHint = resolveTemplateIdHint(input.id);
+    const baseId = idHint || slugify(title) || `template-${randomUUID().slice(0, 8)}`;
+    let id = baseId;
+    let suffix = 2;
+    while (listWorkflowTemplateRows({ id }).length > 0) {
+        id = `${baseId}-${suffix}`;
+        suffix += 1;
+    }
+    insertWorkflowTemplateRow({
+        id,
+        title,
+        description: valueOrEmpty(input.description),
+    });
+    return replaceWorkflowTemplate(id, input.stages);
+}
+const PROTECTED_WORKFLOW_TEMPLATE_IDS = new Set(["ai-sdlc", DEFAULT_WORKFLOW_TEMPLATE_ID]);
+export function deleteWorkflowTemplate(templateId) {
+    ensureDefaultWorkflowTemplates();
+    const id = templateId;
+    if (PROTECTED_WORKFLOW_TEMPLATE_IDS.has(id)) {
+        throw new AppError("Built-in template cannot be deleted", 403);
+    }
+    if (listWorkflowTemplateRows({ id }).length === 0) {
+        throw new AppError("Workflow template not found", 404);
+    }
+    deleteWorkflowTemplateRow(id);
+}
+export function copyTemplateStagesToProject(projectId, templateId) {
+    const template = getWorkflowTemplate(templateId);
+    if (!template) {
+        throw new AppError("Workflow template not found", 404);
+    }
+    const id = projectId;
+    deleteWorkflowStagesForProject(id);
+    for (const stage of template.stages) {
+        insertWorkflowStageRow({
+            id: stage.id,
+            projectId: id,
+            title: stage.title,
+            description: stage.description,
+            purpose: "",
+            rulesJson: "[]",
+            position: stage.position,
+            autoAssignRole: "",
+            layoutX: stage.layoutX,
+            layoutY: stage.layoutY,
+            spawnTaskCount: stage.taskTemplates.length,
+            taskTemplatesJson: serializeTaskTemplates(stage.taskTemplates),
+        });
+    }
+    return template.stages;
+}