@umudik/task-bridge 0.0.1

package/apps/backend/dist/routes/workflow-templates.js

@@ -0,0 +1,152 @@
+import { z } from "zod";
+import { AppError } from "../errors/app-error.js";
+import { assertAuth } from "../middleware/auth.js";
+import { createWorkflowTemplate, deleteWorkflowTemplate, getWorkflowTemplate, importWorkflowTemplate, listWorkflowTemplates, replaceWorkflowTemplate, } from "../services/workflow-template-service.js";
+const templateIdParamsSchema = z.object({
+    templateId: z.string().trim().min(1),
+});
+const taskTemplateSchema = z.lazy(() => z.object({
+    id: z.string().trim().min(1),
+    title: z.string().trim().min(1),
+    description: z.string().trim().optional().default(""),
+    assigneeRole: z.string().trim().optional().default(""),
+    dependsOn: z.array(z.string().trim()).optional().default([]),
+    children: z.array(taskTemplateSchema).optional().default([]),
+}));
+const stageSchema = z.object({
+    id: z.string().trim().min(1),
+    title: z.string().trim().min(1),
+    description: z.string().trim().optional().default(""),
+    position: z.number().int().nonnegative(),
+    autoAssignRole: z.string().trim().optional().default(""),
+    layoutX: z.number().nullable().optional(),
+    layoutY: z.number().nullable().optional(),
+    spawnTaskCount: z.number().int().nonnegative().optional().default(0),
+    taskTemplates: z.array(taskTemplateSchema).optional().default([]),
+});
+const replaceTemplateSchema = z.object({
+    stages: z.array(stageSchema).min(1),
+});
+const createTemplateSchema = z.object({
+    id: z.string().trim().min(1).nullable().default(null),
+    title: z.string().trim().min(1),
+    description: z.string().trim().optional().default(""),
+});
+const importSchema = z.object({
+    id: z.string().trim().min(1).nullable().default(null),
+    title: z.string().trim().min(1),
+    description: z.string().trim().optional().default(""),
+    stages: z.array(stageSchema).min(1),
+}).passthrough();
+export function workflowTemplateRoutes(app) {
+    app.get("/workflow-templates", (request) => {
+        assertAuth(request);
+        return { items: listWorkflowTemplates() };
+    });
+    // POST /api/workflow-templates/import — must be before /:templateId routes
+    app.post("/workflow-templates/import", async (request, reply) => {
+        assertAuth(request);
+        let importBody = request.body;
+        if (importBody === null) {
+            importBody = {};
+        }
+        const body = importSchema.parse(importBody);
+        const template = importWorkflowTemplate({
+            id: body.id,
+            title: body.title,
+            description: body.description,
+            stages: body.stages.map((stage) => {
+                let layoutX = null;
+                if (Number(stage.layoutX) === stage.layoutX) {
+                    layoutX = stage.layoutX;
+                }
+                let layoutY = null;
+                if (Number(stage.layoutY) === stage.layoutY) {
+                    layoutY = stage.layoutY;
+                }
+                let autoAssignRole = null;
+                if (stage.autoAssignRole) {
+                    autoAssignRole = stage.autoAssignRole;
+                }
+                return Object.assign({}, stage, { layoutX, layoutY, autoAssignRole, activeTaskCount: null });
+            }),
+        });
+        return reply.status(201).send(template);
+    });
+    app.post("/workflow-templates", async (request, reply) => {
+        assertAuth(request);
+        let createTemplateBody = request.body;
+        if (createTemplateBody === null) {
+            createTemplateBody = {};
+        }
+        const body = createTemplateSchema.parse(createTemplateBody);
+        const template = createWorkflowTemplate({
+            id: body.id,
+            title: body.title,
+            description: body.description,
+        });
+        return reply.status(201).send(template);
+    });
+    app.get("/workflow-templates/:templateId", async (request, reply) => {
+        assertAuth(request);
+        const { templateId } = templateIdParamsSchema.parse(request.params);
+        const template = getWorkflowTemplate(templateId);
+        if (!template) {
+            return reply.status(404).send({ error: "Workflow template not found" });
+        }
+        return template;
+    });
+    // GET /api/workflow-templates/:templateId/export — download as JSON file
+    app.get("/workflow-templates/:templateId/export", async (request, reply) => {
+        assertAuth(request);
+        const { templateId } = templateIdParamsSchema.parse(request.params);
+        const template = getWorkflowTemplate(templateId);
+        if (!template) {
+            throw new AppError("Workflow template not found", 404);
+        }
+        const payload = {
+            exportedFrom: "task-bridge",
+            version: 1,
+            id: template.id,
+            title: template.title,
+            description: template.description,
+            stages: template.stages,
+        };
+        const filename = `${template.id}.json`;
+        return reply
+            .header("Content-Type", "application/json; charset=utf-8")
+            .header("Content-Disposition", `attachment; filename="${filename}"`)
+            .send(JSON.stringify(payload, null, 2));
+    });
+    app.put("/workflow-templates/:templateId", async (request, reply) => {
+        assertAuth(request);
+        const { templateId } = templateIdParamsSchema.parse(request.params);
+        let replaceTemplateBody = request.body;
+        if (replaceTemplateBody === null) {
+            replaceTemplateBody = {};
+        }
+        const body = replaceTemplateSchema.parse(replaceTemplateBody);
+        const template = replaceWorkflowTemplate(templateId, body.stages.map((stage) => {
+            let layoutX = null;
+            if (Number(stage.layoutX) === stage.layoutX) {
+                layoutX = stage.layoutX;
+            }
+            let layoutY = null;
+            if (Number(stage.layoutY) === stage.layoutY) {
+                layoutY = stage.layoutY;
+            }
+            let autoAssignRole = null;
+            if (stage.autoAssignRole) {
+                autoAssignRole = stage.autoAssignRole;
+            }
+            return Object.assign({}, stage, { layoutX, layoutY, autoAssignRole, activeTaskCount: null });
+        }));
+        return reply.status(200).send(template);
+    });
+    app.delete("/workflow-templates/:templateId", async (request, reply) => {
+        assertAuth(request);
+        const { templateId } = templateIdParamsSchema.parse(request.params);
+        deleteWorkflowTemplate(templateId);
+        return reply.status(204).send();
+    });
+}

package/apps/backend/dist/routes/workflow.js

@@ -0,0 +1,165 @@
+import { z } from "zod";
+import { AppError } from "../errors/app-error.js";
+import { assertAuth } from "../middleware/auth.js";
+import { getProjectById } from "../services/project-registry.js";
+import { createProjectMember, ensureProjectWorkflow, applyWorkflowTemplateToProject, exportWorkflowReadable, getProjectWorkflow, removeProjectMember, replaceProjectWorkflow, updateProjectMember, } from "../services/workflow-service.js";
+const projectIdParamsSchema = z.object({
+    projectId: z.string().trim().min(1),
+});
+const memberIdParamsSchema = z.object({
+    projectId: z.string().trim().min(1),
+    memberId: z.string().trim().min(1),
+});
+const taskTemplateSchema = z.lazy(() => z.object({
+    id: z.string().trim().min(1),
+    title: z.string().trim().min(1),
+    description: z.string().trim().optional().default(""),
+    assigneeRole: z.string().trim().optional().default(""),
+    dependsOn: z.array(z.string().trim()).optional().default([]),
+    children: z.array(taskTemplateSchema).optional().default([]),
+}));
+const stageSchema = z.object({
+    id: z.string().trim().min(1),
+    title: z.string().trim().min(1),
+    description: z.string().trim().optional().default(""),
+    position: z.number().int().nonnegative(),
+    autoAssignRole: z.string().trim().optional().default(""),
+    layoutX: z.number().nullable().optional(),
+    layoutY: z.number().nullable().optional(),
+    spawnTaskCount: z.number().int().nonnegative().optional().default(0),
+    taskTemplates: z.array(taskTemplateSchema).optional().default([]),
+});
+const replaceWorkflowSchema = z.object({
+    stages: z.array(stageSchema).min(1),
+    roles: z.array(z.string().trim()).optional().default([]),
+});
+const applyTemplateSchema = z.object({
+    templateId: z.string().trim().min(1),
+});
+const createMemberSchema = z.object({
+    name: z.string().trim().min(1),
+    role: z.string().trim().optional().default(""),
+});
+const updateMemberSchema = z.object({
+    name: z.string().trim().min(1).optional(),
+    role: z.string().trim().optional(),
+});
+function assertProject(projectId) {
+    const project = getProjectById(projectId);
+    if (!project) {
+        throw new AppError("Project not found", 404);
+    }
+    ensureProjectWorkflow(projectId);
+    return project;
+}
+export function workflowRoutes(app) {
+    app.get("/projects/:projectId/workflow", (request) => {
+        assertAuth(request);
+        const { projectId } = projectIdParamsSchema.parse(request.params);
+        assertProject(projectId);
+        return getProjectWorkflow(projectId);
+    });
+    app.get("/projects/:projectId/workflow/export", (request) => {
+        assertAuth(request);
+        const { projectId } = projectIdParamsSchema.parse(request.params);
+        assertProject(projectId);
+        return exportWorkflowReadable(projectId);
+    });
+    app.post("/projects/:projectId/workflow/apply-template", async (request, reply) => {
+        assertAuth(request);
+        const { projectId } = projectIdParamsSchema.parse(request.params);
+        assertProject(projectId);
+        let applyTemplateBody = request.body;
+        if (applyTemplateBody === null) {
+            applyTemplateBody = {};
+        }
+        const body = applyTemplateSchema.parse(applyTemplateBody);
+        const workflow = applyWorkflowTemplateToProject(projectId, body.templateId);
+        return reply.status(200).send(workflow);
+    });
+    app.put("/projects/:projectId/workflow", async (request, reply) => {
+        assertAuth(request);
+        const { projectId } = projectIdParamsSchema.parse(request.params);
+        assertProject(projectId);
+        let replaceWorkflowBody = request.body;
+        if (replaceWorkflowBody === null) {
+            replaceWorkflowBody = {};
+        }
+        const body = replaceWorkflowSchema.parse(replaceWorkflowBody);
+        const workflow = replaceProjectWorkflow(projectId, body.stages.map((stage) => {
+            let layoutX = null;
+            if (Number(stage.layoutX) === stage.layoutX) {
+                layoutX = stage.layoutX;
+            }
+            let layoutY = null;
+            if (Number(stage.layoutY) === stage.layoutY) {
+                layoutY = stage.layoutY;
+            }
+            let autoAssignRole = null;
+            if (stage.autoAssignRole) {
+                autoAssignRole = stage.autoAssignRole;
+            }
+            return Object.assign({}, stage, { layoutX, layoutY, autoAssignRole, activeTaskCount: null });
+        }), body.roles);
+        return reply.status(200).send(workflow);
+    });
+    app.get("/projects/:projectId/members", (request) => {
+        assertAuth(request);
+        const { projectId } = projectIdParamsSchema.parse(request.params);
+        assertProject(projectId);
+        const workflow = getProjectWorkflow(projectId);
+        return { items: workflow.members };
+    });
+    app.post("/projects/:projectId/members", async (request, reply) => {
+        assertAuth(request);
+        const { projectId } = projectIdParamsSchema.parse(request.params);
+        assertProject(projectId);
+        let createMemberBody = request.body;
+        if (createMemberBody === null) {
+            createMemberBody = {};
+        }
+        const body = createMemberSchema.parse(createMemberBody);
+        const member = createProjectMember({
+            projectId,
+            name: body.name,
+            role: body.role,
+        });
+        return reply.status(201).send(member);
+    });
+    app.patch("/projects/:projectId/members/:memberId", async (request, reply) => {
+        assertAuth(request);
+        const { projectId, memberId } = memberIdParamsSchema.parse(request.params);
+        assertProject(projectId);
+        let updateMemberBody = request.body;
+        if (updateMemberBody === null) {
+            updateMemberBody = {};
+        }
+        const body = updateMemberSchema.parse(updateMemberBody);
+        let updateName = null;
+        if ("name" in body) {
+            updateName = body.name;
+        }
+        let updateRole = null;
+        if ("role" in body) {
+            updateRole = body.role;
+        }
+        const member = updateProjectMember(memberId, {
+            name: updateName,
+            role: updateRole,
+        });
+        if (!member || member.projectId !== projectId) {
+            return reply.status(404).send({ error: "Member not found" });
+        }
+        return member;
+    });
+    app.delete("/projects/:projectId/members/:memberId", async (request, reply) => {
+        assertAuth(request);
+        const { projectId, memberId } = memberIdParamsSchema.parse(request.params);
+        assertProject(projectId);
+        const removed = removeProjectMember(memberId);
+        if (!removed) {
+            return reply.status(404).send({ error: "Member not found" });
+        }
+        return reply.status(204).send();
+    });
+}

package/apps/backend/dist/services/connect-target.js

@@ -0,0 +1,4 @@
+// Ngrok-based connect target removed.
+export function resolveConnectTarget() {
+    return null;
+}

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

@@ -0,0 +1,269 @@
+import { listWorkflowStageRows, } from "../db/workflow-db.js";
+import { isWorkDone } from "../domain/work-status.js";
+import { assertCanAdvanceWorkStatus, listDescendantIds, listEpicWorkflowTasks, resolveEpicId, resolveTaskStageId, } from "../domain/task.js";
+import { stageHasActionableTemplates } from "../domain/workflow-stage.js";
+import { buildEpicClaimIndex, normalizeClaimActor, workflowUpdateBlockReason, } from "./task-claim-policy.js";
+import { AppError } from "../errors/app-error.js";
+import { getBridgeTask, listBridgeTasks, transitionBridgeTask } from "./task-service.js";
+import { deleteTaskRows, mutateTaskRow } from "../db/tasks-db.js";
+import { touchTask } from "../domain/task.js";
+import { spawnEpicWorkflowGraph, spawnUnlockedWorkflowTasks } from "./workflow-spawn-service.js";
+import { resetWorkflowStateNodesForTasks, rollbackEpicWorkflowFromStage, syncEpicWorkflowStage, syncTaskIntoWorkflowState, } from "./workflow-state-service.js";
+export function isEpic(task) {
+    return task.parentId === null;
+}
+function stageTemplateInput(row) {
+    return {
+        taskTemplatesJson: row.task_templates_json,
+        stageId: row.id,
+        stageTitle: row.title,
+    };
+}
+export function computeEpicStageId(stageRows, subtasks) {
+    const ordered = stageRows.slice().sort((a, b) => a.position - b.position);
+    if (ordered.length === 0)
+        return null;
+    for (const row of ordered) {
+        if (!stageHasActionableTemplates(stageTemplateInput(row)))
+            continue;
+        const stageTasks = subtasks.filter((task) => resolveTaskStageId(subtasks, task) === row.id);
+        const hasIncomplete = stageTasks.some((task) => !isWorkDone(task));
+        if (hasIncomplete || stageTasks.length === 0)
+            return row.id;
+    }
+    if (ordered.length > 0) {
+        const last = ordered[ordered.length - 1];
+        if (last) {
+            return last.id;
+        }
+    }
+    return null;
+}
+export function syncEpicStage(epicId) {
+    const epic = getBridgeTask(epicId);
+    if (!epic || epic.parentId !== null)
+        return epic;
+    const rows = listWorkflowStageRows({ projectId: epic.projectId, stageId: "" }).sort((a, b) => a.position - b.position);
+    let current = epic;
+    for (let pass = 0; pass < rows.length + 1; pass += 1) {
+        const allTasks = listBridgeTasks();
+        const subtasks = listEpicWorkflowTasks(allTasks, epicId);
+        const nextStageId = computeEpicStageId(rows, subtasks);
+        if (!nextStageId || nextStageId === current.stageId)
+            break;
+        const transitioned = transitionBridgeTask(epicId, {
+            stageId: nextStageId,
+            assignee: null,
+            by: "workflow",
+        });
+        if (transitioned !== null) {
+            current = transitioned;
+            syncEpicWorkflowStage(epicId, nextStageId);
+        }
+    }
+    spawnUnlockedWorkflowTasks(current);
+    return current;
+}
+export function spawnEpicWorkflow(epic) {
+    return spawnEpicWorkflowGraph(epic);
+}
+export function collectLaterStageTodoCascadeIds(tasks, source, stageRows) {
+    const stageId = resolveTaskStageId(tasks, source);
+    if (!stageId)
+        return [];
+    let epicId;
+    if (source.epicId !== null && source.epicId !== null) {
+        epicId = source.epicId;
+    }
+    else {
+        epicId = resolveEpicId(tasks, source);
+    }
+    if (!epicId)
+        return [];
+    const ordered = stageRows.slice().sort((a, b) => a.position - b.position);
+    const stageIndex = ordered.findIndex((row) => row.id === stageId);
+    if (stageIndex < 0)
+        return [];
+    const ids = new Set();
+    const laterStageIds = new Set(ordered.slice(stageIndex + 1).map((row) => row.id));
+    for (const task of listEpicWorkflowTasks(tasks, epicId)) {
+        if (task.id === source.id)
+            continue;
+        const taskStageId = resolveTaskStageId(tasks, task);
+        if (!taskStageId || !laterStageIds.has(taskStageId))
+            continue;
+        ids.add(task.id);
+        for (const descendantId of listDescendantIds(tasks, task.id)) {
+            ids.add(descendantId);
+        }
+    }
+    return Array.from(ids);
+}
+export function applyTodoCascadeFromTask(source, by, options) {
+    const includeLaterStages = options === null || options.laterStages !== false;
+    const includeDescendants = options === null || options.descendants !== false;
+    const tasks = listBridgeTasks();
+    let epicId;
+    if (source.epicId !== null && source.epicId !== null) {
+        epicId = source.epicId;
+    }
+    else {
+        epicId = resolveEpicId(tasks, source);
+    }
+    let epicTask = null;
+    if (epicId !== null) {
+        for (const task of tasks) {
+            if (task.id === epicId) {
+                epicTask = task;
+                break;
+            }
+        }
+    }
+    let projectId;
+    if (epicTask !== null) {
+        projectId = epicTask.projectId;
+    }
+    else {
+        projectId = source.projectId;
+    }
+    let stageRows;
+    if (epicId !== null) {
+        stageRows = listWorkflowStageRows({ projectId, stageId: "" });
+    }
+    else {
+        stageRows = [];
+    }
+    const sourceStageId = resolveTaskStageId(tasks, source);
+    const deleteIds = new Set();
+    const resetIds = new Set();
+    if (includeDescendants) {
+        for (const descendantId of listDescendantIds(tasks, source.id)) {
+            resetIds.add(descendantId);
+        }
+    }
+    if (includeLaterStages) {
+        for (const laterId of collectLaterStageTodoCascadeIds(tasks, source, stageRows)) {
+            deleteIds.add(laterId);
+            resetIds.delete(laterId);
+        }
+    }
+    deleteTaskRows(Array.from(deleteIds));
+    const at = new Date().toISOString();
+    for (const cascadeId of resetIds) {
+        mutateTaskRow(cascadeId, (task) => {
+            if (task.workStatus === "todo")
+                return;
+            task.workStatus = "todo";
+            task.claimedBy = null;
+            task.claimedAt = null;
+            task.events.push({
+                type: "spec_updated",
+                at,
+                by,
+                note: `work_status:todo:cascade:${source.id}`,
+            });
+            touchTask(task);
+        });
+    }
+    if (epicId !== null && sourceStageId) {
+        if (deleteIds.size > 0) {
+            rollbackEpicWorkflowFromStage(epicId, sourceStageId, projectId);
+        }
+        resetWorkflowStateNodesForTasks(epicId, resetIds);
+    }
+}
+export function updateTaskWorkStatus(taskId, workStatus, by, actor) {
+    const existing = getBridgeTask(taskId);
+    if (!existing || existing.parentId === null) {
+        return existing;
+    }
+    const tasksForPolicy = listBridgeTasks();
+    assertCanAdvanceWorkStatus(tasksForPolicy, existing, workStatus);
+    const normalized = normalizeClaimActor(actor);
+    const index = buildEpicClaimIndex(tasksForPolicy);
+    const blockReason = workflowUpdateBlockReason(existing, index, normalized, workStatus);
+    if (blockReason) {
+        throw new AppError(blockReason, 409);
+    }
+    const updated = mutateTaskRow(taskId, (task) => {
+        if (task.parentId === null)
+            return;
+        task.workStatus = workStatus;
+        const at = new Date().toISOString();
+        task.events.push({
+            type: "spec_updated",
+            at,
+            by,
+            note: `work_status:${workStatus}`,
+        });
+        touchTask(task);
+    });
+    if (!updated || updated.parentId === null) {
+        return updated;
+    }
+    if (workStatus === "todo" || workStatus === "in_progress") {
+        const reopening = isWorkDone(existing);
+        applyTodoCascadeFromTask(updated, by, {
+            laterStages: workStatus === "todo" || reopening,
+            descendants: true,
+        });
+    }
+    syncTaskIntoWorkflowState(updated);
+    const allTasks = listBridgeTasks();
+    let epicId;
+    if (updated.epicId !== null && updated.epicId !== null) {
+        epicId = updated.epicId;
+    }
+    else {
+        epicId = resolveEpicId(allTasks, updated);
+    }
+    if (!epicId)
+        return updated;
+    const epic = getBridgeTask(epicId);
+    if (!epic)
+        return updated;
+    spawnUnlockedWorkflowTasks(epic);
+    syncEpicStage(epicId);
+    return updated;
+}
+export function listEpicSubtasks(epicId) {
+    const tasks = listBridgeTasks();
+    return listEpicWorkflowTasks(tasks, epicId);
+}
+export function getEpicWithStage(epicId) {
+    const epic = getBridgeTask(epicId);
+    if (!epic || epic.parentId !== null)
+        return null;
+    const rawSynced = syncEpicStage(epicId);
+    let synced;
+    if (rawSynced !== null) {
+        synced = rawSynced;
+    }
+    else {
+        synced = epic;
+    }
+    let stageRows;
+    if (synced.stageId !== null && synced.stageId !== "") {
+        stageRows = listWorkflowStageRows({ projectId: synced.projectId, stageId: synced.stageId });
+    }
+    else {
+        stageRows = [];
+    }
+    let stageTitle;
+    if (stageRows.length > 0) {
+        const firstRow = stageRows[0];
+        if (firstRow) {
+            stageTitle = firstRow.title;
+        }
+        else {
+            stageTitle = synced.stageId;
+        }
+    }
+    else {
+        stageTitle = synced.stageId;
+    }
+    return {
+        epic: synced,
+        stageTitle,
+    };
+}