@umudik/task-bridge 0.0.1

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

@@ -0,0 +1,222 @@
+import { randomUUID } from "node:crypto";
+import { deleteLibraryDocumentLink, deleteLibraryDocumentRow, deleteLibraryRow, insertLibraryDocumentLink, insertLibraryDocumentRow, insertLibraryRow, listLibraryDocumentLinkRowsForDocument, listLibraryDocumentLinkRowsForTask, listLibraryDocumentRows, listLibraryRows, updateLibraryDocumentRow, updateLibraryRow, } from "../db/library-db.js";
+import { listTaskRows } from "../db/tasks-db.js";
+import { AppError } from "../errors/app-error.js";
+function slugify(value) {
+    return value
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function resolveLibraryId(inputId, title) {
+    const custom = inputId;
+    if (custom !== "")
+        return custom;
+    const base = slugify(title) || `library-${randomUUID()}`;
+    let candidate = base;
+    let suffix = 1;
+    while (listLibraryRows({ id: candidate }).length > 0) {
+        candidate = `${base}-${suffix}`;
+        suffix += 1;
+    }
+    return candidate;
+}
+function resolveDocumentId(inputId, title, libraryId) {
+    const custom = inputId;
+    if (custom !== "")
+        return custom;
+    const base = slugify(title) || `doc-${randomUUID()}`;
+    let candidate = base;
+    let suffix = 1;
+    while (listLibraryDocumentRows({ libraryId: "", documentId: candidate }).length > 0) {
+        candidate = `${base}-${suffix}`;
+        suffix += 1;
+    }
+    if (listLibraryDocumentRows({ libraryId: "", documentId: candidate }).length > 0) {
+        return `${libraryId}-${candidate}`;
+    }
+    return candidate;
+}
+function mapLibraryDetail(row) {
+    return {
+        id: row.id,
+        title: row.title,
+        description: row.description,
+        documents: listLibraryDocumentRows({ libraryId: row.id, documentId: "" }).map((doc) => ({
+            id: doc.id,
+            libraryId: doc.library_id,
+            title: doc.title,
+            description: doc.description,
+        })),
+    };
+}
+function mapLibraryDocument(row) {
+    const libraries = listLibraryRows({ id: row.library_id });
+    let libraryTitle;
+    const libraryRow = libraries[0];
+    if (libraryRow) {
+        libraryTitle = libraryRow.title;
+    }
+    else {
+        libraryTitle = row.library_id;
+    }
+    return {
+        id: row.id,
+        libraryId: row.library_id,
+        libraryTitle,
+        title: row.title,
+        description: row.description,
+        linkCount: listLibraryDocumentLinkRowsForDocument(row.id).length,
+    };
+}
+export function listLibraries() {
+    return listLibraryRows({ id: "" }).map((row) => ({
+        id: row.id,
+        title: row.title,
+        description: row.description,
+        documentCount: listLibraryDocumentRows({ libraryId: row.id, documentId: "" }).length,
+    }));
+}
+export function getLibrary(libraryId) {
+    const rows = listLibraryRows({ id: libraryId });
+    if (rows.length === 0)
+        return null;
+    const row = rows[0];
+    if (!row)
+        return null;
+    return mapLibraryDetail(row);
+}
+export function createLibrary(input) {
+    const title = input.title;
+    if (title === "")
+        throw new AppError("Title is required", 400);
+    const id = resolveLibraryId(input.id, title);
+    if (listLibraryRows({ id }).length > 0)
+        throw new AppError("Library already exists", 409);
+    insertLibraryRow({ id, title, description: input.description });
+    const created = getLibrary(id);
+    if (created === null)
+        throw new AppError("Library creation failed", 500);
+    return created;
+}
+export function updateLibrary(libraryId, input) {
+    const rows = listLibraryRows({ id: libraryId });
+    if (rows.length === 0)
+        throw new AppError("Library not found", 404);
+    const title = input.title;
+    if (title === "")
+        throw new AppError("Title is required", 400);
+    updateLibraryRow(libraryId, { title, description: input.description });
+    const updated = getLibrary(libraryId);
+    if (updated === null)
+        throw new AppError("Library not found after update", 500);
+    return updated;
+}
+export function removeLibrary(libraryId) {
+    if (listLibraryRows({ id: libraryId }).length === 0) {
+        throw new AppError("Library not found", 404);
+    }
+    deleteLibraryRow(libraryId);
+}
+export function getLibraryDocument(documentId) {
+    const rows = listLibraryDocumentRows({ libraryId: "", documentId });
+    if (rows.length === 0)
+        return null;
+    const row = rows[0];
+    if (!row)
+        return null;
+    return mapLibraryDocument(row);
+}
+export function createLibraryDocument(libraryId, input) {
+    if (listLibraryRows({ id: libraryId }).length === 0) {
+        throw new AppError("Library not found", 404);
+    }
+    const title = input.title;
+    if (title === "")
+        throw new AppError("Title is required", 400);
+    const id = resolveDocumentId(input.id, title, libraryId);
+    if (listLibraryDocumentRows({ libraryId: "", documentId: id }).length > 0) {
+        throw new AppError("Document already exists", 409);
+    }
+    insertLibraryDocumentRow({
+        id,
+        libraryId,
+        title,
+        description: input.description,
+    });
+    const created = getLibraryDocument(id);
+    if (created === null)
+        throw new AppError("Document creation failed", 500);
+    return created;
+}
+export function updateLibraryDocument(documentId, input) {
+    if (listLibraryDocumentRows({ libraryId: "", documentId }).length === 0) {
+        throw new AppError("Document not found", 404);
+    }
+    const title = input.title;
+    if (title === "")
+        throw new AppError("Title is required", 400);
+    updateLibraryDocumentRow(documentId, { title, description: input.description });
+    const updated = getLibraryDocument(documentId);
+    if (updated === null)
+        throw new AppError("Document not found after update", 500);
+    return updated;
+}
+export function removeLibraryDocument(documentId) {
+    if (listLibraryDocumentRows({ libraryId: "", documentId }).length === 0) {
+        throw new AppError("Document not found", 404);
+    }
+    deleteLibraryDocumentRow(documentId);
+}
+export function linkDocumentToTask(documentId, taskId) {
+    if (listLibraryDocumentRows({ libraryId: "", documentId }).length === 0) {
+        throw new AppError("Document not found", 404);
+    }
+    const tasks = listTaskRows({ id: taskId });
+    if (tasks.length === 0)
+        throw new AppError("Task not found", 404);
+    const task = tasks[0];
+    if (!task)
+        throw new AppError("Task not found", 404);
+    if (task.parentId !== null) {
+        throw new AppError("Documents can only be linked to epics", 400);
+    }
+    insertLibraryDocumentLink(documentId, taskId);
+    return listTaskLibraryLinks(taskId);
+}
+export function unlinkDocumentFromTask(documentId, taskId) {
+    if (listLibraryDocumentRows({ libraryId: "", documentId }).length === 0) {
+        throw new AppError("Document not found", 404);
+    }
+    deleteLibraryDocumentLink(documentId, taskId);
+}
+export function listTaskLibraryLinks(taskId) {
+    if (listTaskRows({ id: taskId }).length === 0)
+        return [];
+    return listLibraryDocumentLinkRowsForTask(taskId).flatMap((link) => {
+        const docs = listLibraryDocumentRows({ libraryId: "", documentId: link.document_id });
+        if (docs.length === 0)
+            return [];
+        const document = docs[0];
+        if (!document)
+            return [];
+        const libraries = listLibraryRows({ id: document.library_id });
+        let libraryTitle;
+        const libraryRow = libraries[0];
+        if (libraryRow) {
+            libraryTitle = libraryRow.title;
+        }
+        else {
+            libraryTitle = document.library_id;
+        }
+        return [
+            {
+                documentId: document.id,
+                documentTitle: document.title,
+                libraryId: document.library_id,
+                libraryTitle,
+                taskId: link.task_id,
+                linkedAt: link.created_at,
+            },
+        ];
+    });
+}

package/apps/backend/dist/services/project-registry.js

@@ -0,0 +1,122 @@
+import { getProjectsDb, insertProjectRow, listProjectRows, listProjectRowsById, updateProjectRow, } from "../db/projects-db.js";
+import { migrateEpicWorkflowTables } from "../db/epic-workflow-db.js";
+import { copyTemplateStagesToProject, ensureDefaultWorkflowTemplates, } from "./workflow-template-service.js";
+import { applyWorkflowTemplateToProject } from "./workflow-service.js";
+import { normalizeWorkflowTemplateId, } from "../domain/workflow-template-id.js";
+function normalizeRepoPath(value) {
+    if (String(value) !== value)
+        return null;
+    if (!value)
+        return null;
+    return value;
+}
+function rowToProject(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        repoPath: normalizeRepoPath(row.repo_path),
+        description: row.description,
+        workflowTemplateId: normalizeWorkflowTemplateId(row.workflow_template_id),
+    };
+}
+function slugifyProjectId(name) {
+    const mapped = name
+        .replace(/ş/g, "s")
+        .replace(/ğ/g, "g")
+        .replace(/ü/g, "u")
+        .replace(/ö/g, "o")
+        .replace(/ç/g, "c")
+        .replace(/ı/g, "i")
+        .replace(/İ/g, "i");
+    return mapped
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+export function initProjectRegistry() {
+    getProjectsDb();
+    migrateEpicWorkflowTables();
+    ensureDefaultWorkflowTemplates();
+}
+export function refreshProjectRegistry() {
+    return listProjectRows().map(rowToProject);
+}
+export function listPublicProjects() {
+    return listProjectRows().map((row) => ({
+        id: row.id,
+        name: row.name,
+        repoPath: normalizeRepoPath(row.repo_path),
+        description: row.description,
+        workflowTemplateId: normalizeWorkflowTemplateId(row.workflow_template_id),
+    }));
+}
+export function createProject(input) {
+    const name = input.name;
+    const repoPath = input.repoPath;
+    if (!name || !repoPath)
+        return null;
+    const inputId = input.id;
+    const id = inputId || slugifyProjectId(name);
+    if (!id || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id))
+        return null;
+    if (listProjectRowsById(id).length > 0)
+        return "duplicate";
+    const templateId = normalizeWorkflowTemplateId(input.workflowTemplateId);
+    const description = input.description;
+    if (!insertProjectRow(id, name, repoPath, description, templateId)) {
+        return "duplicate";
+    }
+    copyTemplateStagesToProject(id, templateId);
+    const rows = listProjectRowsById(id);
+    const row = rows[0];
+    if (row) {
+        return rowToProject(row);
+    }
+    return null;
+}
+export function updateProject(projectId, input) {
+    const existing = getProjectById(projectId);
+    if (!existing)
+        return null;
+    const name = input.name;
+    const repoPath = input.repoPath;
+    if (!name || !repoPath)
+        return null;
+    const description = input.description;
+    const workflowTemplateId = normalizeWorkflowTemplateId(input.workflowTemplateId);
+    const templateChanged = workflowTemplateId !== existing.workflowTemplateId;
+    if (templateChanged) {
+        applyWorkflowTemplateToProject(projectId, workflowTemplateId);
+    }
+    if (!updateProjectRow(projectId, {
+        name,
+        repoPath,
+        description,
+        workflowTemplateId,
+    })) {
+        return null;
+    }
+    return getProjectById(projectId);
+}
+export function updateProjectRepoPath(projectId, repoPath) {
+    const existing = getProjectById(projectId);
+    if (!existing)
+        return null;
+    return updateProject(projectId, {
+        name: existing.name,
+        repoPath: repoPath,
+        description: existing.description,
+        workflowTemplateId: existing.workflowTemplateId,
+    });
+}
+export function getProjectById(projectId) {
+    const id = projectId;
+    if (!id)
+        return null;
+    const rows = listProjectRowsById(id);
+    const row = rows[0];
+    if (row) {
+        return rowToProject(row);
+    }
+    return null;
+}
+export function resetProjectRegistryCache() { }

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

@@ -0,0 +1,42 @@
+import { listProjectMemberRows, listWorkflowStageRows } from "../db/workflow-db.js";
+import { AppError } from "../errors/app-error.js";
+function pickRandomMember(members) {
+    const index = Math.floor(Math.random() * members.length);
+    const member = members[index];
+    if (!member) {
+        throw new AppError("No project members to assign task", 400);
+    }
+    return member.name;
+}
+export function pickMemberByProjectRole(projectId, _roleName) {
+    const members = listProjectMemberRows({ projectId, id: "" });
+    if (members.length === 0) {
+        throw new AppError("No project members to assign task", 400);
+    }
+    return pickRandomMember(members);
+}
+export function resolveTaskAssignee(input) {
+    let explicit = "";
+    if (input.assignee !== null) {
+        explicit = input.assignee;
+    }
+    if (explicit) {
+        return { assignee: explicit, assigneeRole: input.assigneeRole };
+    }
+    let role = "";
+    if (input.assigneeRole !== null) {
+        role = input.assigneeRole;
+    }
+    if (!role && input.stageId) {
+        const stageRows = listWorkflowStageRows({
+            projectId: input.projectId,
+            stageId: input.stageId,
+        });
+        const stage = stageRows[0];
+        if (stage) {
+            role = stage.auto_assign_role;
+        }
+    }
+    const assignee = pickMemberByProjectRole(input.projectId, role);
+    return { assignee, assigneeRole: role || input.assigneeRole };
+}

package/apps/backend/dist/services/task-claim-policy.js

@@ -0,0 +1,310 @@
+import { listWorkflowStageRows, } from "../db/workflow-db.js";
+import { flattenTemplateNodes } from "../domain/task-template-graph.js";
+import { findProjectMember } from "../domain/project-member.js";
+import { isWorkDone, resolveWorkStatus } from "../domain/work-status.js";
+import { listEpicWorkflowTasks } from "../domain/task.js";
+import { resolveStageTaskTemplates } from "../domain/workflow-stage.js";
+import { emptyToNull } from "../lib/strings.js";
+import { computeEpicStageId } from "./epic-service.js";
+export function resolveClaimActor(projectId, memberName) {
+    const member = findProjectMember(projectId, memberName);
+    if (!member)
+        return null;
+    return {
+        claimedBy: member.name,
+        role: member.role,
+    };
+}
+export function normalizeClaimActor(actor) {
+    return {
+        claimedBy: actor.claimedBy,
+        role: actor.role,
+    };
+}
+function latestCommentByRole(comments, role) {
+    for (let index = comments.length - 1; index >= 0; index -= 1) {
+        const entry = comments[index];
+        if (!entry)
+            continue;
+        if (entry.role === role)
+            return entry;
+    }
+    return null;
+}
+export function userAwaitingReply(task) {
+    const lastUser = latestCommentByRole(task.comments, "user");
+    if (!lastUser)
+        return false;
+    const lastSystem = latestCommentByRole(task.comments, "system");
+    if (!lastSystem)
+        return true;
+    const humanAt = Date.parse(lastUser.at);
+    const systemAt = Date.parse(lastSystem.at);
+    if (Number.isNaN(humanAt) || Number.isNaN(systemAt))
+        return true;
+    return humanAt > systemAt;
+}
+export function rolesMatch(_actorRole, _requiredRole) {
+    return true;
+}
+export function resolveTaskClaimRole(task) {
+    if (task.parentId === null)
+        return null;
+    if (task.assigneeRole)
+        return task.assigneeRole;
+    if (task.templateId) {
+        for (const row of listWorkflowStageRows({ projectId: task.projectId, stageId: "" })) {
+            const roots = resolveStageTaskTemplates({
+                taskTemplatesJson: row.task_templates_json,
+                stageId: row.id,
+                stageTitle: row.title,
+            });
+            for (const node of flattenTemplateNodes(roots)) {
+                if (node.id === task.templateId && node.assigneeRole) {
+                    return node.assigneeRole;
+                }
+            }
+        }
+    }
+    if (task.assignee !== null) {
+        const member = findProjectMember(task.projectId, task.assignee);
+        if (member !== null)
+            return member.role;
+    }
+    if (task.stageId !== null) {
+        const stageRows = listWorkflowStageRows({
+            projectId: task.projectId,
+            stageId: task.stageId,
+        });
+        if (stageRows.length > 0) {
+            const stageRow = stageRows[0];
+            if (!stageRow)
+                return null;
+            const autoRole = emptyToNull(stageRow.auto_assign_role);
+            if (autoRole)
+                return autoRole;
+        }
+    }
+    return null;
+}
+export function buildEpicClaimIndex(tasks) {
+    const activeStageByEpic = new Map();
+    const stagePositionByProject = new Map();
+    const epics = tasks.filter((task) => task.parentId === null);
+    for (const epic of epics) {
+        if (!stagePositionByProject.has(epic.projectId)) {
+            const positions = new Map();
+            for (const row of listWorkflowStageRows({ projectId: epic.projectId, stageId: "" }).sort((a, b) => a.position - b.position)) {
+                positions.set(row.id, row.position);
+            }
+            stagePositionByProject.set(epic.projectId, positions);
+        }
+        const stageRows = listWorkflowStageRows({ projectId: epic.projectId, stageId: "" }).sort((a, b) => a.position - b.position);
+        const subtasks = listEpicWorkflowTasks(tasks, epic.id);
+        activeStageByEpic.set(epic.id, computeEpicStageId(stageRows, subtasks));
+    }
+    return { activeStageByEpic, stagePositionByProject };
+}
+export function isTaskOnEpicActiveStage(task, index) {
+    if (!task.stageId)
+        return false;
+    let epicId;
+    if (task.epicId !== null) {
+        epicId = task.epicId;
+    }
+    else {
+        epicId = task.parentId;
+    }
+    if (!epicId)
+        return false;
+    const activeStageId = index.activeStageByEpic.get(epicId);
+    return activeStageId === task.stageId;
+}
+export function passesWorkflowClaimGate(task, index) {
+    if (task.parentId === null)
+        return false;
+    if (isWorkDone(task))
+        return false;
+    return isTaskOnEpicActiveStage(task, index);
+}
+export function canActorClaimTask(task, index, _actor) {
+    if (task.parentId === null || isWorkDone(task))
+        return false;
+    if (userAwaitingReply(task)) {
+        return true;
+    }
+    if (task.claimedBy)
+        return false;
+    return passesWorkflowClaimGate(task, index);
+}
+export function canActorUpdateWorkStatus(task, index, actor) {
+    if (task.parentId === null || isWorkDone(task))
+        return false;
+    if (!isTaskOnEpicActiveStage(task, index))
+        return false;
+    if (task.claimedBy && task.claimedBy !== actor.claimedBy)
+        return false;
+    return true;
+}
+export function workflowUpdateBlockReason(task, index, actor, nextWorkStatus = null) {
+    if (task.parentId === null)
+        return "Epics cannot be updated";
+    const isReopen = isWorkDone(task) &&
+        nextWorkStatus !== null &&
+        (nextWorkStatus === "todo" || nextWorkStatus === "in_progress");
+    if (isWorkDone(task) && !isReopen) {
+        return "Task is already done";
+    }
+    if (!isReopen && !isTaskOnEpicActiveStage(task, index)) {
+        return "Task is not on the active pipeline step";
+    }
+    if (!isReopen && task.claimedBy && task.claimedBy !== actor.claimedBy) {
+        return "Task is claimed by another member";
+    }
+    return null;
+}
+export function isWorkflowClaimable(task, index, actor) {
+    if (actor === null) {
+        if (userAwaitingReply(task))
+            return task.parentId !== null && !isWorkDone(task);
+        if (task.claimedBy)
+            return false;
+        return passesWorkflowClaimGate(task, index);
+    }
+    return canActorClaimTask(task, index, actor);
+}
+function activeStageSortKey(task, index) {
+    if (!task.parentId)
+        return Number.MAX_SAFE_INTEGER;
+    const positions = index.stagePositionByProject.get(task.projectId);
+    const activeStageId = index.activeStageByEpic.get(task.parentId);
+    if (!positions || !activeStageId)
+        return Number.MAX_SAFE_INTEGER;
+    if (!positions.has(activeStageId)) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    return positions.get(activeStageId);
+}
+function workStatusSortKey(task) {
+    const status = resolveWorkStatus(task);
+    if (status === "in_progress")
+        return 0;
+    if (status === "todo")
+        return 1;
+    return 2;
+}
+export function compareWorkflowClaimPriority(a, b, index) {
+    let awaitingA;
+    if (userAwaitingReply(a)) {
+        awaitingA = 0;
+    }
+    else {
+        awaitingA = 1;
+    }
+    let awaitingB;
+    if (userAwaitingReply(b)) {
+        awaitingB = 0;
+    }
+    else {
+        awaitingB = 1;
+    }
+    if (awaitingA !== awaitingB)
+        return awaitingA - awaitingB;
+    const stageA = activeStageSortKey(a, index);
+    const stageB = activeStageSortKey(b, index);
+    if (stageA !== stageB)
+        return stageA - stageB;
+    let epicAId;
+    if (a.epicId !== null) {
+        epicAId = a.epicId;
+    }
+    else {
+        epicAId = a.parentId;
+    }
+    let epicBId;
+    if (b.epicId !== null) {
+        epicBId = b.epicId;
+    }
+    else {
+        epicBId = b.parentId;
+    }
+    let epicA;
+    if (epicAId !== null) {
+        epicA = epicAId;
+    }
+    else {
+        epicA = Number.MAX_SAFE_INTEGER;
+    }
+    let epicB;
+    if (epicBId !== null) {
+        epicB = epicBId;
+    }
+    else {
+        epicB = Number.MAX_SAFE_INTEGER;
+    }
+    if (epicA !== epicB)
+        return epicA - epicB;
+    const workA = workStatusSortKey(a);
+    const workB = workStatusSortKey(b);
+    if (workA !== workB)
+        return workA - workB;
+    const createdA = Date.parse(a.createdAt);
+    const createdB = Date.parse(b.createdAt);
+    if (!Number.isNaN(createdA) && !Number.isNaN(createdB) && createdA !== createdB) {
+        return createdA - createdB;
+    }
+    return a.id - b.id;
+}
+export function sortWorkflowClaimCandidates(tasks, index) {
+    return tasks.slice().sort((a, b) => compareWorkflowClaimPriority(a, b, index));
+}
+export function workflowClaimBlockReason(task, index, actor) {
+    if (task.parentId === null)
+        return "Epics cannot be claimed";
+    if (isWorkDone(task))
+        return "Task is already done";
+    if (actor !== null) {
+        if (!userAwaitingReply(task)) {
+            if (task.claimedBy)
+                return "Task is already claimed";
+            if (!isTaskOnEpicActiveStage(task, index)) {
+                let epicId;
+                if (task.epicId !== null) {
+                    epicId = task.epicId;
+                }
+                else {
+                    epicId = task.parentId;
+                }
+                let activeStageId = null;
+                if (epicId !== null) {
+                    if (index.activeStageByEpic.has(epicId)) {
+                        activeStageId = index.activeStageByEpic.get(epicId);
+                    }
+                }
+                if (!activeStageId)
+                    return "Epic has no active pipeline step";
+                return `Task is on a later pipeline step; epic is at "${activeStageId}"`;
+            }
+        }
+        return null;
+    }
+    if (!isTaskOnEpicActiveStage(task, index)) {
+        let epicId;
+        if (task.epicId !== null) {
+            epicId = task.epicId;
+        }
+        else {
+            epicId = task.parentId;
+        }
+        let activeStageId = null;
+        if (epicId !== null) {
+            if (index.activeStageByEpic.has(epicId)) {
+                activeStageId = index.activeStageByEpic.get(epicId);
+            }
+        }
+        if (!activeStageId)
+            return "Epic has no active pipeline step";
+        return `Task is on a later pipeline step; epic is at "${activeStageId}"`;
+    }
+    return null;
+}