@umudik/task-bridge 0.0.1

package/apps/backend/dist/domain/project-member.js

@@ -0,0 +1,15 @@
+import { listProjectMemberRows } from "../db/workflow-db.js";
+export function findProjectMember(projectId, memberName) {
+    const name = memberName;
+    if (name === "") {
+        return null;
+    }
+    const row = listProjectMemberRows({ projectId, id: "" }).find((entry) => entry.name === name);
+    if (!row) {
+        return null;
+    }
+    return {
+        name: row.name,
+        role: row.role,
+    };
+}

package/apps/backend/dist/domain/task-template-graph.js

@@ -0,0 +1,63 @@
+export function flattenTemplateNodes(nodes) {
+    const result = [];
+    for (const node of nodes) {
+        result.push(node);
+        if (node.children.length > 0) {
+            for (const child of flattenTemplateNodes(node.children)) {
+                result.push(child);
+            }
+        }
+    }
+    return result;
+}
+export function countSpawnableTemplates(nodes) {
+    let count = 0;
+    for (const node of nodes) {
+        count += 1;
+        if (node.children.length > 0) {
+            count += countSpawnableTemplates(node.children);
+        }
+    }
+    return count;
+}
+function dependenciesMet(node, ctx) {
+    return node.dependsOn.every((templateId) => ctx.doneTemplateIds.has(templateId));
+}
+function stageIsReachable(ctx) {
+    return ctx.stagePosition <= ctx.activeStagePosition;
+}
+export function collectSpawnableTemplates(nodes, ctx) {
+    if (!stageIsReachable(ctx))
+        return [];
+    const result = [];
+    for (const node of nodes) {
+        if (!node)
+            continue;
+        if (!dependenciesMet(node, ctx))
+            continue;
+        if (!ctx.spawnedTemplateIds.has(node.id)) {
+            result.push(node);
+            continue;
+        }
+        if (node.children.length > 0) {
+            if (!ctx.doneTemplateIds.has(node.id))
+                continue;
+            for (const child of collectSpawnableTemplates(node.children, ctx)) {
+                result.push(child);
+            }
+        }
+    }
+    return result;
+}
+export function collectSiblingTemplateIds(nodes) {
+    const ids = [];
+    for (const node of nodes) {
+        ids.push(node.id);
+        if (node.children.length > 0) {
+            for (const childId of collectSiblingTemplateIds(node.children)) {
+                ids.push(childId);
+            }
+        }
+    }
+    return ids;
+}

package/apps/backend/dist/domain/task.js

@@ -0,0 +1,93 @@
+import { AppError } from "../errors/app-error.js";
+import { isWorkDone } from "./work-status.js";
+export const DONE_STAGE_ID = "done";
+export function isDoneStage(stageId) {
+    return stageId === DONE_STAGE_ID;
+}
+export function isTaskClaimed(task) {
+    return task.claimedBy !== null && task.claimedBy !== "";
+}
+export function touchTask(task) {
+    task.updatedAt = new Date().toISOString();
+}
+export function sortTasks(tasks) {
+    return tasks.slice().sort((a, b) => {
+        const aTime = Date.parse(a.updatedAt || a.createdAt);
+        const bTime = Date.parse(b.updatedAt || b.createdAt);
+        if (!Number.isNaN(aTime) && !Number.isNaN(bTime) && aTime !== bTime) {
+            return bTime - aTime;
+        }
+        return b.id - a.id;
+    });
+}
+export function listSubtasks(tasks, parentId) {
+    return sortTasks(tasks.filter((task) => task.parentId === parentId));
+}
+export function listDescendantIds(tasks, parentId) {
+    const ids = [];
+    for (const child of listSubtasks(tasks, parentId)) {
+        ids.push(child.id);
+        for (const descendantId of listDescendantIds(tasks, child.id)) {
+            ids.push(descendantId);
+        }
+    }
+    return ids;
+}
+export function listEpicWorkflowTasks(tasks, epicId) {
+    return sortTasks(tasks.filter((task) => {
+        const resolved = task.epicId || resolveEpicId(tasks, task);
+        return resolved === epicId;
+    }));
+}
+export function resolveTaskStageId(tasks, task) {
+    if (task.stageId)
+        return task.stageId;
+    if (!task.parentId)
+        return null;
+    const parent = tasks.find((entry) => entry.id === task.parentId);
+    if (!parent)
+        return null;
+    return resolveTaskStageId(tasks, parent);
+}
+export function resolveEpicId(tasks, task) {
+    if (task.epicId !== null)
+        return task.epicId;
+    if (task.parentId === null)
+        return null;
+    const parent = tasks.find((entry) => entry.id === task.parentId);
+    if (!parent)
+        return task.parentId;
+    if (parent.parentId === null)
+        return parent.id;
+    return resolveEpicId(tasks, parent);
+}
+export function incompleteSubtasks(tasks, parentId) {
+    return listSubtasks(tasks, parentId).filter((task) => !isWorkDone(task));
+}
+export function assertCanAdvanceWorkStatus(tasks, task, nextStatus) {
+    if (nextStatus === "todo")
+        return;
+    if (!task.parentId)
+        return;
+    const parent = tasks.find((entry) => entry.id === task.parentId);
+    if (!parent || parent.parentId === null)
+        return;
+    if (!isWorkDone(parent)) {
+        throw new AppError("Parent task must be done first", 409);
+    }
+}
+export function assertCanCompleteTask(tasks, task) {
+    const blocked = incompleteSubtasks(tasks, task.id);
+    if (blocked.length === 0)
+        return;
+    throw new AppError(`Cannot complete: ${blocked.length} subtask(s) are not done`, 409, {
+        subtasks: blocked.map((entry) => ({
+            id: entry.id,
+            title: entry.title,
+            stageId: entry.stageId,
+        })),
+    });
+}
+export function canonicalDescription(task) {
+    return task.description;
+}

package/apps/backend/dist/domain/work-status.js

@@ -0,0 +1,30 @@
+import { isDoneStage } from "./task.js";
+export const WORK_STATUSES = ["todo", "in_progress", "done"];
+export function isWorkStatus(value) {
+    if (value === null) {
+        return false;
+    }
+    return WORK_STATUSES.includes(value);
+}
+export function resolveWorkStatus(task) {
+    if (task.workStatus && isWorkStatus(task.workStatus)) {
+        return task.workStatus;
+    }
+    if (task.parentId === null) {
+        return "todo";
+    }
+    if (isDoneStage(task.stageId)) {
+        return "done";
+    }
+    return "todo";
+}
+export function isWorkDone(task) {
+    return resolveWorkStatus(task) === "done";
+}
+export function workStatusLabel(status) {
+    if (status === "in_progress")
+        return "In progress";
+    if (status === "done")
+        return "Done";
+    return "Todo";
+}

package/apps/backend/dist/domain/workflow-stage.js

@@ -0,0 +1,186 @@
+export const SUBTASK_SPAWN_STAGE_ID = "in-progress";
+function isStringRecord(value) {
+    return value !== null && value instanceof Object && !Array.isArray(value);
+}
+export function parseStageRolesJson(raw) {
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isStringRecord(parsed))
+            return {};
+        const result = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            const valueStr = value;
+            if (value !== null &&
+                String(valueStr) === valueStr &&
+                valueStr) {
+                result[key] = valueStr;
+            }
+        }
+        return result;
+    }
+    catch {
+        return {};
+    }
+}
+export function serializeStageRolesJson(roles) {
+    return JSON.stringify(roles);
+}
+export function parseRulesJson(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        const result = [];
+        for (const item of parsed) {
+            if (item !== null &&
+                String(item) === item &&
+                item.length > 0) {
+                result.push(item);
+            }
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}
+export function resolveEpicDescription(input) {
+    const parts = [];
+    const description = input.description;
+    const purpose = input.purpose;
+    if (description)
+        parts.push(description);
+    if (purpose && purpose !== description)
+        parts.push(purpose);
+    const rules = parseRulesJson(input.rulesJson);
+    if (rules.length > 0)
+        parts.push(rules.join("\n\n"));
+    return parts.join("\n\n");
+}
+function resolveTaskDescription(row) {
+    const descCandidate = row.description;
+    if (row.description !== null && String(descCandidate) === descCandidate) {
+        return descCandidate;
+    }
+    return "";
+}
+function parseTemplateNode(item, index, fallbackTitle) {
+    let id;
+    const idCandidate = item.id;
+    if (item.id !== null && String(idCandidate) === idCandidate && idCandidate) {
+        id = idCandidate;
+    }
+    else {
+        id = `tpl-${index}`;
+    }
+    let title;
+    const titleCandidate = item.title;
+    if (item.title !== null && String(titleCandidate) === titleCandidate) {
+        title = titleCandidate;
+    }
+    else {
+        title = "";
+    }
+    if (!title)
+        return null;
+    const template = {
+        id,
+        title: title || fallbackTitle,
+        description: resolveTaskDescription(item),
+        assigneeRole: null,
+        dependsOn: [],
+        children: [],
+    };
+    const assigneeRoleCandidate = item.assigneeRole;
+    if (item.assigneeRole !== null &&
+        String(assigneeRoleCandidate) === assigneeRoleCandidate &&
+        assigneeRoleCandidate) {
+        template.assigneeRole = assigneeRoleCandidate;
+    }
+    if (Array.isArray(item.dependsOn)) {
+        const deps = [];
+        for (const entry of item.dependsOn) {
+            if (entry !== null &&
+                String(entry) === entry &&
+                entry.length > 0) {
+                deps.push(entry);
+            }
+        }
+        template.dependsOn = deps;
+    }
+    if (Array.isArray(item.children)) {
+        template.children = parseTaskTemplateNodes(item.children, "Task");
+    }
+    return template;
+}
+function parseTaskTemplateNodes(raw, fallbackTitle) {
+    const result = [];
+    for (let i = 0; i < raw.length; i += 1) {
+        const node = raw[i];
+        if (!node)
+            continue;
+        const parsed = parseTemplateNode(node, i, fallbackTitle);
+        if (parsed !== null)
+            result.push(parsed);
+    }
+    return result;
+}
+export function parseTaskTemplatesJson(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parseTaskTemplateNodes(parsed, "Task");
+    }
+    catch {
+        return [];
+    }
+}
+function serializeTemplateNode(template) {
+    let assigneeRole = null;
+    if (template.assigneeRole) {
+        assigneeRole = template.assigneeRole;
+    }
+    let children = null;
+    if (template.children.length > 0) {
+        children = template.children.map((child) => serializeTemplateNode(child));
+    }
+    return {
+        id: template.id,
+        title: template.title,
+        description: template.description,
+        assigneeRole,
+        dependsOn: template.dependsOn,
+        children,
+    };
+}
+export function serializeTaskTemplates(templates) {
+    return JSON.stringify(templates.map((template) => serializeTemplateNode(template)));
+}
+export function resolveStageTaskTemplates(input) {
+    return parseTaskTemplatesJson(input.taskTemplatesJson);
+}
+export function resolveStageTaskTemplateRoots(input) {
+    return resolveStageTaskTemplates(input);
+}
+function templateTreeHasTasks(nodes) {
+    return nodes.some((node) => node.title.length > 0);
+}
+export function stageHasActionableTemplates(input) {
+    const roots = resolveStageTaskTemplateRoots(input);
+    return templateTreeHasTasks(roots);
+}
+export function countSpawnableTemplates(templates) {
+    let count = 0;
+    for (const node of templates) {
+        count += 1;
+        if (node.children.length > 0) {
+            count += countSpawnableTemplates(node.children);
+        }
+    }
+    return count;
+}

package/apps/backend/dist/domain/workflow-state.js

@@ -0,0 +1,73 @@
+import { resolveStageTaskTemplateRoots, } from "./workflow-stage.js";
+function walkTemplateNodes(nodes, stageId, parentTemplateId, out) {
+    for (const node of nodes) {
+        out[node.id] = {
+            templateId: node.id,
+            stageId,
+            parentTemplateId,
+            title: node.title,
+            description: node.description,
+            assigneeRole: node.assigneeRole,
+            workStatus: "todo",
+            comments: [],
+            taskId: null,
+        };
+        let children;
+        if (node.children !== null) {
+            children = node.children;
+        }
+        else {
+            children = [];
+        }
+        if (children.length > 0) {
+            walkTemplateNodes(children, stageId, node.id, out);
+        }
+    }
+}
+export function buildInitialWorkflowState(input) {
+    const nodes = {};
+    for (const stage of input.stages) {
+        const roots = resolveStageTaskTemplateRoots({
+            taskTemplatesJson: stage.taskTemplatesJson,
+            stageId: stage.id,
+            stageTitle: stage.title,
+        });
+        walkTemplateNodes(roots, stage.id, null, nodes);
+    }
+    return {
+        stageId: input.stageId,
+        nodes,
+    };
+}
+export function parseWorkflowStateData(raw) {
+    if (!raw)
+        return null;
+    try {
+        const row = JSON.parse(raw);
+        if (!row.nodes || !(row.nodes instanceof Object) || Array.isArray(row.nodes))
+            return null;
+        const nodes = row.nodes;
+        let stageId = null;
+        if (row.stageId !== null && String(row.stageId) === row.stageId) {
+            stageId = row.stageId || null;
+        }
+        return { stageId, nodes };
+    }
+    catch {
+        return null;
+    }
+}
+export function serializeWorkflowStateData(data) {
+    return JSON.stringify(data);
+}
+export function summarizeWorkflowStateNodes(data) {
+    return Object.values(data.nodes).map((node) => ({
+        templateId: node.templateId,
+        stageId: node.stageId,
+        parentTemplateId: node.parentTemplateId,
+        title: node.title,
+        taskId: node.taskId,
+        workStatus: node.workStatus,
+        commentCount: node.comments.length,
+    }));
+}

package/apps/backend/dist/domain/workflow-template-id.js

@@ -0,0 +1,6 @@
+export const DEFAULT_WORKFLOW_TEMPLATE_ID = "empty";
+export function normalizeWorkflowTemplateId(value) {
+    if (value === "")
+        return DEFAULT_WORKFLOW_TEMPLATE_ID;
+    return value;
+}

package/apps/backend/dist/errors/app-error.js

@@ -0,0 +1,24 @@
+export class AppError extends Error {
+    statusCode;
+    details;
+    constructor(message, statusCode, details = null) {
+        super(message);
+        this.name = "AppError";
+        this.statusCode = statusCode;
+        this.details = details;
+    }
+}
+export function isAppError(error) {
+    return error instanceof AppError;
+}
+export function statusCodeFromError(error) {
+    if (isAppError(error))
+        return error.statusCode;
+    if (error instanceof Object && "statusCode" in error) {
+        const code = Number(error.statusCode);
+        if (Number.isFinite(code)) {
+            return code;
+        }
+    }
+    return 500;
+}

package/apps/backend/dist/index.js

@@ -0,0 +1,67 @@
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import { ZodError } from "zod";
+import { isAppError, statusCodeFromError } from "./errors/app-error.js";
+import { createLogger } from "./logger.js";
+import { config } from "./config.js";
+import { healthRoutes } from "./routes/health.js";
+import { projectRoutes } from "./routes/projects.js";
+import { taskRoutes } from "./routes/tasks.js";
+import { workflowRoutes } from "./routes/workflow.js";
+import { workflowTemplateRoutes } from "./routes/workflow-templates.js";
+import { libraryRoutes } from "./routes/library.js";
+import { webRoutes } from "./routes/web.js";
+import { authRoutes } from "./routes/auth.js";
+import { adminUserRoutes } from "./routes/admin-users.js";
+import { docsRoutes } from "./routes/docs.js";
+import { refreshProjectRegistry, initProjectRegistry } from "./services/project-registry.js";
+const logger = createLogger("backend");
+async function main() {
+    const app = Fastify({ logger: false });
+    await app.register(cors, { origin: true });
+    initProjectRegistry();
+    refreshProjectRegistry();
+    healthRoutes(app);
+    await app.register((apiApp) => {
+        docsRoutes(apiApp);
+        authRoutes(apiApp);
+        adminUserRoutes(apiApp);
+        projectRoutes(apiApp);
+        taskRoutes(apiApp);
+        workflowRoutes(apiApp);
+        workflowTemplateRoutes(apiApp);
+        libraryRoutes(apiApp);
+    }, { prefix: "/api" });
+    await webRoutes(app);
+    app.setErrorHandler((error, _request, reply) => {
+        if (error instanceof ZodError) {
+            return reply.status(400).send({ error: error.message });
+        }
+        const handled = error;
+        const statusCode = statusCodeFromError(handled);
+        let message = "Internal error";
+        if (error instanceof Error) {
+            message = error.message;
+        }
+        if (statusCode >= 500) {
+            logger.error(message);
+        }
+        const body = { error: message, details: null };
+        if (isAppError(handled) && handled.details !== null) {
+            body.details = handled.details;
+        }
+        return reply.status(statusCode).send(body);
+    });
+    await app.listen({ port: config.port, host: "0.0.0.0" });
+    logger.info(`Server listening on port ${config.port}`);
+    logger.info(`Web UI: http://localhost:${config.port}/app/login`);
+    logger.info("Projects loaded from database");
+}
+main().catch((err) => {
+    let errMessage = String(err);
+    if (err instanceof Error) {
+        errMessage = err.message;
+    }
+    logger.error("Failed to start", { error: errMessage });
+    process.exit(1);
+});

package/apps/backend/dist/lib/bridge-project.js

@@ -0,0 +1,24 @@
+export const PROJECT_TAG_PATTERN = /^\[project:([^\]]+)\]\s*(?:\n\n?|\r\n\r\n?)?/;
+export function withProjectMarker(projectId, description) {
+    const body = description;
+    if (body)
+        return `[project:${projectId}]\n\n${body}`;
+    return `[project:${projectId}]`;
+}
+export function extractProjectId(description) {
+    if (!description)
+        return null;
+    const match = description.match(PROJECT_TAG_PATTERN);
+    if (!match)
+        return null;
+    const id = match[1];
+    if (!id)
+        return null;
+    return id || null;
+}
+export function stripProjectMarker(description) {
+    if (!description)
+        return null;
+    const stripped = description.replace(PROJECT_TAG_PATTERN, "");
+    return stripped || null;
+}

package/apps/backend/dist/lib/inbox-cursor.js

@@ -0,0 +1,34 @@
+import { Buffer } from "node:buffer";
+export function encodeInboxCursor(item) {
+    let activityAt = "";
+    if (item.activityAt !== null) {
+        activityAt = item.activityAt;
+    }
+    else if (item.createdAt !== null) {
+        activityAt = item.createdAt;
+    }
+    return Buffer.from(`${activityAt}|${item.taskId}`, "utf8").toString("base64url");
+}
+export function decodeInboxCursor(cursor) {
+    try {
+        const decoded = Buffer.from(cursor, "base64url").toString("utf8");
+        const lastPipe = decoded.lastIndexOf("|");
+        if (lastPipe < 0)
+            return null;
+        const activityAt = decoded.slice(0, lastPipe);
+        const taskId = Number(decoded.slice(lastPipe + 1));
+        if (!Number.isFinite(taskId) || taskId <= 0)
+            return null;
+        return { activityAt, taskId };
+    }
+    catch {
+        return null;
+    }
+}
+export function inboxItemBeforeCursor(item, cursorTime, cursorTaskId, parseActivityTime) {
+    const itemTime = parseActivityTime(item);
+    if (!Number.isNaN(itemTime) && !Number.isNaN(cursorTime) && itemTime !== cursorTime) {
+        return itemTime < cursorTime;
+    }
+    return item.taskId < cursorTaskId;
+}

package/apps/backend/dist/lib/strings.js

@@ -0,0 +1,15 @@
+export function valueOrEmpty(value) {
+    if (value === null) {
+        return "";
+    }
+    return value;
+}
+export function emptyToNull(value) {
+    if (value === null) {
+        return null;
+    }
+    if (value === "") {
+        return null;
+    }
+    return value;
+}

package/apps/backend/dist/logger.js

@@ -0,0 +1,29 @@
+const LEVEL_ORDER = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+export function createLogger(name, minLevel = "info") {
+    const log = (level, message, meta = null) => {
+        if (LEVEL_ORDER[level] < LEVEL_ORDER[minLevel])
+            return;
+        let suffix = "";
+        if (meta !== null && Object.keys(meta).length > 0) {
+            suffix = ` ${JSON.stringify(meta)}`;
+        }
+        const line = `[${new Date().toISOString()}] [${level.toUpperCase()}] [${name}] ${message}${suffix}`;
+        if (level === "error" || level === "warn") {
+            process.stderr.write(`${line}\n`);
+        }
+        else {
+            process.stdout.write(`${line}\n`);
+        }
+    };
+    return {
+        debug: (message, meta = null) => log("debug", message, meta),
+        info: (message, meta = null) => log("info", message, meta),
+        warn: (message, meta = null) => log("warn", message, meta),
+        error: (message, meta = null) => log("error", message, meta),
+    };
+}