@danalexilewis/taskgraph 0.1.0

package/dist/db/query.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonObj = jsonObj;
+exports.now = now;
+exports.query = query;
+const connection_1 = require("./connection");
+const escape_1 = require("./escape");
+function jsonObj(value) {
+    return { _type: "json", value };
+}
+function now() {
+    return new Date().toISOString().slice(0, 19).replace("T", " ");
+}
+function formatValue(value) {
+    if (value === null) {
+        return "NULL";
+    }
+    if (typeof value === "boolean" || typeof value === "number") {
+        return String(value);
+    }
+    if (typeof value === "string") {
+        return `'${(0, escape_1.sqlEscape)(value)}'`;
+    }
+    if (value._type === "json") {
+        const jsonPairs = Object.entries(value.value)
+            .map(([key, val]) => {
+            return `'${(0, escape_1.sqlEscape)(key)}', '${(0, escape_1.sqlEscape)(JSON.stringify(val))}'`;
+        })
+            .join(", ");
+        return `JSON_OBJECT(${jsonPairs})`;
+    }
+    // Should not happen with SqlValue type
+    return `'${(0, escape_1.sqlEscape)(String(value))}'`;
+}
+function backtickWrap(name) {
+    return `\`${name}\``;
+}
+function buildWhereClause(where) {
+    const parts = [];
+    for (const [key, val] of Object.entries(where)) {
+        if (typeof val === "object" && val !== null && "op" in val) {
+            parts.push(`${backtickWrap(key)} ${val.op} ${formatValue(val.value)}`);
+        }
+        else {
+            parts.push(`${backtickWrap(key)} = ${formatValue(val)}`);
+        }
+    }
+    return parts.join(" AND ");
+}
+function query(repoPath) {
+    return {
+        insert: (table, data) => {
+            const cols = Object.keys(data).map(backtickWrap).join(", ");
+            const vals = Object.values(data).map(formatValue).join(", ");
+            const sql = `INSERT INTO ${backtickWrap(table)} (${cols}) VALUES (${vals})`;
+            return (0, connection_1.doltSql)(sql, repoPath).map((res) => res);
+        },
+        update: (table, data, where) => {
+            const setParts = Object.entries(data)
+                .map(([key, val]) => `${backtickWrap(key)} = ${formatValue(val)}`)
+                .join(", ");
+            const whereClause = buildWhereClause(where);
+            const sql = `UPDATE ${backtickWrap(table)} SET ${setParts} WHERE ${whereClause}`;
+            return (0, connection_1.doltSql)(sql, repoPath).map((res) => res);
+        },
+        select: (table, options) => {
+            let sql = `SELECT ${options?.columns?.map(backtickWrap).join(", ") ?? "*"} FROM ${backtickWrap(table)}`;
+            const whereClause = options?.where && Object.keys(options.where).length > 0
+                ? buildWhereClause(options.where)
+                : "";
+            if (whereClause) {
+                sql += ` WHERE ${whereClause}`;
+            }
+            if (options?.groupBy && options.groupBy.length > 0) {
+                sql += ` GROUP BY ${options.groupBy.map(backtickWrap).join(", ")}`;
+            }
+            if (options?.having) {
+                sql += ` HAVING ${options.having}`;
+            }
+            if (options?.orderBy) {
+                sql += ` ORDER BY ${options.orderBy}`; // orderBy expected to be already escaped/formatted
+            }
+            if (options?.limit) {
+                sql += ` LIMIT ${options.limit}`;
+            }
+            if (options?.offset) {
+                sql += ` OFFSET ${options.offset}`;
+            }
+            return (0, connection_1.doltSql)(sql, repoPath).map((res) => res);
+        },
+        count: (table, where) => {
+            let sql = `SELECT COUNT(*) AS count FROM ${backtickWrap(table)}`;
+            if (where) {
+                sql += ` WHERE ${buildWhereClause(where)}`;
+            }
+            return (0, connection_1.doltSql)(sql, repoPath).map((res) => res[0]?.count ?? 0);
+        },
+        raw: (sql) => {
+            return (0, connection_1.doltSql)(sql, repoPath).map((res) => res);
+        },
+    };
+}

package/dist/domain/errors.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildError = exports.ErrorCode = void 0;
+var ErrorCode;
+(function (ErrorCode) {
+    // DB errors
+    ErrorCode["DB_QUERY_FAILED"] = "DB_QUERY_FAILED";
+    ErrorCode["DB_COMMIT_FAILED"] = "DB_COMMIT_FAILED";
+    ErrorCode["DB_PARSE_FAILED"] = "DB_PARSE_FAILED";
+    // Domain errors
+    ErrorCode["TASK_NOT_FOUND"] = "TASK_NOT_FOUND";
+    ErrorCode["TASK_ALREADY_CLAIMED"] = "TASK_ALREADY_CLAIMED";
+    ErrorCode["PLAN_NOT_FOUND"] = "PLAN_NOT_FOUND";
+    ErrorCode["INVALID_TRANSITION"] = "INVALID_TRANSITION";
+    ErrorCode["TASK_NOT_RUNNABLE"] = "TASK_NOT_RUNNABLE";
+    ErrorCode["CYCLE_DETECTED"] = "CYCLE_DETECTED";
+    ErrorCode["EDGE_EXISTS"] = "EDGE_EXISTS";
+    // Config errors
+    ErrorCode["CONFIG_NOT_FOUND"] = "CONFIG_NOT_FOUND";
+    ErrorCode["CONFIG_PARSE_FAILED"] = "CONFIG_PARSE_FAILED";
+    // Import errors
+    ErrorCode["FILE_READ_FAILED"] = "FILE_READ_FAILED";
+    ErrorCode["PARSE_FAILED"] = "PARSE_FAILED";
+    // Validation
+    ErrorCode["VALIDATION_FAILED"] = "VALIDATION_FAILED";
+    ErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+const buildError = (code, message, cause) => ({
+    code,
+    message,
+    cause,
+});
+exports.buildError = buildError;

package/dist/domain/invariants.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNoBlockerCycle = checkNoBlockerCycle;
+exports.checkRunnable = checkRunnable;
+exports.checkValidTransition = checkValidTransition;
+const neverthrow_1 = require("neverthrow");
+const neverthrow_2 = require("neverthrow");
+const errors_1 = require("./errors");
+const query_1 = require("../db/query");
+const escape_1 = require("../db/escape");
+// Helper for cycle detection (DFS)
+function hasCycleDFS(start, current, graph, visited, recursionStack) {
+    visited.add(current);
+    recursionStack.add(current);
+    const neighbors = graph.get(current) || [];
+    for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+            if (hasCycleDFS(start, neighbor, graph, visited, recursionStack)) {
+                return true;
+            }
+        }
+        else if (recursionStack.has(neighbor)) {
+            return true; // Cycle detected
+        }
+    }
+    recursionStack.delete(current);
+    return false;
+}
+function checkNoBlockerCycle(fromTaskId, toTaskId, existingEdges) {
+    const allEdges = [
+        ...existingEdges,
+        {
+            from_task_id: fromTaskId,
+            to_task_id: toTaskId,
+            type: "blocks",
+            reason: null,
+        },
+    ];
+    const graph = new Map();
+    for (const edge of allEdges) {
+        if (edge.type === "blocks") {
+            if (!graph.has(edge.from_task_id)) {
+                graph.set(edge.from_task_id, []);
+            }
+            graph.get(edge.from_task_id)?.push(edge.to_task_id);
+        }
+    }
+    // Check for cycles starting from each node
+    for (const node of graph.keys()) {
+        const visited = new Set();
+        const recursionStack = new Set();
+        if (hasCycleDFS(node, node, graph, visited, recursionStack)) {
+            return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.CYCLE_DETECTED, `Blocking edge from ${fromTaskId} to ${toTaskId} would create a cycle.`));
+        }
+    }
+    return (0, neverthrow_1.ok)(undefined);
+}
+function checkRunnable(taskId, repoPath) {
+    const q = (0, query_1.query)(repoPath);
+    return q
+        .select("task", {
+        columns: ["status"],
+        where: { task_id: taskId },
+    })
+        .andThen((taskResult) => {
+        if (taskResult.length === 0) {
+            return (0, neverthrow_2.errAsync)((0, errors_1.buildError)(errors_1.ErrorCode.TASK_NOT_FOUND, `Task with ID ${taskId} not found.`));
+        }
+        const taskStatus = taskResult[0].status;
+        if (taskStatus !== "todo") {
+            return (0, neverthrow_2.errAsync)((0, errors_1.buildError)(errors_1.ErrorCode.INVALID_TRANSITION, `Task ${taskId} is not in 'todo' status. Current status: ${taskStatus}.`));
+        }
+        const unmetBlockersQuery = `
+        SELECT COUNT(*)
+        FROM \`edge\` e
+        JOIN \`task\` bt ON e.from_task_id = bt.task_id
+        WHERE e.to_task_id = '${(0, escape_1.sqlEscape)(taskId)}'
+          AND e.type = 'blocks'
+          AND bt.status NOT IN ('done','canceled');
+      `;
+        return q.raw(unmetBlockersQuery);
+    })
+        .andThen((blockerCountResult) => {
+        const unmetBlockers = blockerCountResult[0]["COUNT(*)"];
+        if (unmetBlockers > 0) {
+            return (0, neverthrow_2.errAsync)((0, errors_1.buildError)(errors_1.ErrorCode.TASK_NOT_RUNNABLE, `Task ${taskId} has ${unmetBlockers} unmet blockers and is not runnable.`));
+        }
+        return (0, neverthrow_2.okAsync)(undefined);
+    });
+}
+function checkValidTransition(currentStatus, nextStatus) {
+    const validTransitions = {
+        todo: ["doing", "blocked", "canceled"],
+        doing: ["done", "blocked", "canceled"],
+        blocked: ["todo", "canceled"], // Can only go to todo when unblocked, or canceled
+        done: [], // Terminal state
+        canceled: [], // Terminal state
+    };
+    if (!validTransitions[currentStatus].includes(nextStatus)) {
+        return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.INVALID_TRANSITION, `Invalid task status transition from '${currentStatus}' to '${nextStatus}'.`));
+    }
+    return (0, neverthrow_1.ok)(undefined);
+}

package/dist/domain/types.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecisionSchema = exports.EventSchema = exports.EdgeSchema = exports.TaskSkillSchema = exports.TaskDomainSchema = exports.TaskSchema = exports.PlanSchema = exports.PlanRiskEntrySchema = exports.ActorSchema = exports.EventKindSchema = exports.EdgeTypeSchema = exports.ChangeTypeSchema = exports.RiskSchema = exports.OwnerSchema = exports.TaskStatusSchema = exports.PlanStatusSchema = void 0;
+const zod_1 = require("zod");
+// Enums
+exports.PlanStatusSchema = zod_1.z.enum([
+    "draft",
+    "active",
+    "paused",
+    "done",
+    "abandoned",
+]);
+exports.TaskStatusSchema = zod_1.z.enum([
+    "todo",
+    "doing",
+    "blocked",
+    "done",
+    "canceled",
+]);
+exports.OwnerSchema = zod_1.z.enum(["human", "agent"]);
+exports.RiskSchema = zod_1.z.enum(["low", "medium", "high"]);
+exports.ChangeTypeSchema = zod_1.z.enum([
+    "create",
+    "modify",
+    "refactor",
+    "fix",
+    "investigate",
+    "test",
+    "document",
+]);
+exports.EdgeTypeSchema = zod_1.z.enum(["blocks", "relates"]);
+exports.EventKindSchema = zod_1.z.enum([
+    "created",
+    "started",
+    "progress",
+    "blocked",
+    "unblocked",
+    "done",
+    "split",
+    "decision_needed",
+    "note",
+]);
+exports.ActorSchema = zod_1.z.enum(["human", "agent"]);
+// Risk entry for plan.risks (rich planning)
+exports.PlanRiskEntrySchema = zod_1.z.object({
+    description: zod_1.z.string(),
+    severity: exports.RiskSchema,
+    mitigation: zod_1.z.string(),
+});
+// Schemas
+exports.PlanSchema = zod_1.z.object({
+    plan_id: zod_1.z.string().uuid(),
+    title: zod_1.z.string().max(255),
+    intent: zod_1.z.string(),
+    status: exports.PlanStatusSchema.default("draft"),
+    priority: zod_1.z.number().int().default(0),
+    source_path: zod_1.z.string().max(512).nullable(),
+    source_commit: zod_1.z.string().max(64).nullable(),
+    created_at: zod_1.z.string().datetime(),
+    updated_at: zod_1.z.string().datetime(),
+    file_tree: zod_1.z.string().nullable(),
+    risks: zod_1.z.array(exports.PlanRiskEntrySchema).nullable(),
+    tests: zod_1.z.array(zod_1.z.string()).nullable(),
+});
+exports.TaskSchema = zod_1.z.object({
+    task_id: zod_1.z.string().uuid(),
+    plan_id: zod_1.z.string().uuid(),
+    feature_key: zod_1.z.string().max(64).nullable(),
+    title: zod_1.z.string().max(255),
+    intent: zod_1.z.string().nullable(),
+    scope_in: zod_1.z.string().nullable(),
+    scope_out: zod_1.z.string().nullable(),
+    acceptance: zod_1.z.array(zod_1.z.string()).nullable(), // Assuming acceptance is an array of strings
+    status: exports.TaskStatusSchema.default("todo"),
+    owner: exports.OwnerSchema.default("agent"),
+    area: zod_1.z.string().max(64).nullable(),
+    risk: exports.RiskSchema.default("low"),
+    estimate_mins: zod_1.z.number().int().nullable(),
+    created_at: zod_1.z.string().datetime(),
+    updated_at: zod_1.z.string().datetime(),
+    external_key: zod_1.z.string().max(128).nullable(),
+    change_type: exports.ChangeTypeSchema.nullable(),
+    suggested_changes: zod_1.z.string().nullable(),
+});
+/** Junction: task_id + domain (task can have many domains). */
+exports.TaskDomainSchema = zod_1.z.object({
+    task_id: zod_1.z.string().uuid(),
+    domain: zod_1.z.string().max(64),
+});
+/** Junction: task_id + skill (task can have many skills). */
+exports.TaskSkillSchema = zod_1.z.object({
+    task_id: zod_1.z.string().uuid(),
+    skill: zod_1.z.string().max(64),
+});
+exports.EdgeSchema = zod_1.z.object({
+    from_task_id: zod_1.z.string().uuid(),
+    to_task_id: zod_1.z.string().uuid(),
+    type: exports.EdgeTypeSchema.default("blocks"),
+    reason: zod_1.z.string().nullable(),
+});
+exports.EventSchema = zod_1.z.object({
+    event_id: zod_1.z.string().uuid(),
+    task_id: zod_1.z.string().uuid(),
+    kind: exports.EventKindSchema,
+    body: zod_1.z.record(zod_1.z.any()), // JSON type in Dolt maps to a generic record
+    actor: exports.ActorSchema.default("agent"),
+    created_at: zod_1.z.string().datetime(),
+});
+exports.DecisionSchema = zod_1.z.object({
+    decision_id: zod_1.z.string().uuid(),
+    plan_id: zod_1.z.string().uuid(),
+    task_id: zod_1.z.string().uuid().nullable(),
+    summary: zod_1.z.string().max(255),
+    context: zod_1.z.string(),
+    options: zod_1.z.array(zod_1.z.string()).nullable(), // Assuming options is an array of strings
+    decision: zod_1.z.string(),
+    consequences: zod_1.z.string().nullable(),
+    source_ref: zod_1.z.string().max(512).nullable(),
+    created_at: zod_1.z.string().datetime(),
+});

package/dist/export/dot.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDotGraph = formatDotGraph;
+exports.generateDotGraph = generateDotGraph;
+const graph_data_1 = require("./graph-data");
+function formatDotGraph(nodes, edges) {
+    let dot = "digraph TaskGraph {\n";
+    dot += "  rankdir=LR;\n";
+    dot += "  node [shape=box];\n";
+    nodes.forEach((node) => {
+        dot += `  \"${node.id}\" [label=\"${node.label}\"];\n`;
+    });
+    edges.forEach((edge) => {
+        dot += `  \"${edge.from}\" -> \"${edge.to}\" [label=\"${edge.type}\"];\n`;
+    });
+    dot += "}\n";
+    return dot;
+}
+function generateDotGraph(planId, featureKey, basePath) {
+    return (0, graph_data_1.getGraphData)(planId, featureKey, basePath).map(({ nodes, edges }) => formatDotGraph(nodes, edges));
+}

package/dist/export/graph-data.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGraphData = getGraphData;
+const utils_1 = require("../cli/utils");
+const query_1 = require("../db/query");
+function getGraphData(planId, featureKey, basePath) {
+    return (0, utils_1.readConfig)(basePath).asyncAndThen((config) => {
+        // Passed basePath to readConfig
+        const q = (0, query_1.query)(config.doltRepoPath);
+        const whereClause = {};
+        if (planId) {
+            whereClause.plan_id = planId;
+        }
+        if (featureKey) {
+            whereClause.feature_key = featureKey;
+        }
+        return q
+            .select("task", {
+            columns: ["task_id", "title", "status"],
+            where: whereClause,
+        })
+            .andThen((tasksResult) => {
+            const tasks = tasksResult;
+            const edgesQuery = `SELECT from_task_id, to_task_id, type FROM \`edge\`;`;
+            return q.raw(edgesQuery).map((edgesResult) => {
+                const edges = edgesResult;
+                const nodes = tasks.map((task) => ({
+                    id: task.task_id,
+                    label: `${task.title} (${task.status})`,
+                    status: task.status,
+                }));
+                const graphEdges = edges.map((edge) => ({
+                    from: edge.from_task_id,
+                    to: edge.to_task_id,
+                    type: edge.type,
+                }));
+                return { nodes, edges: graphEdges };
+            });
+        });
+    });
+}

package/dist/export/markdown.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMarkdown = generateMarkdown;
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const utils_1 = require("../cli/utils");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+const escape_1 = require("../db/escape");
+/** Generates Cursor-format markdown from plan and tasks. */
+function generateMarkdown(planId, basePath) {
+    return (0, utils_1.readConfig)(basePath).asyncAndThen((config) => {
+        const q = (0, query_1.query)(config.doltRepoPath);
+        return q
+            .select("plan", {
+            columns: ["plan_id", "title", "intent"],
+            where: { plan_id: planId },
+        })
+            .andThen((plans) => {
+            if (plans.length === 0) {
+                return (0, neverthrow_1.errAsync)((0, errors_1.buildError)(errors_1.ErrorCode.PLAN_NOT_FOUND, `Plan ${planId} not found`));
+            }
+            const plan = plans[0];
+            return q
+                .select("task", {
+                columns: ["task_id", "external_key", "title", "status"],
+                where: { plan_id: planId },
+            })
+                .andThen((tasks) => {
+                const taskIds = tasks.map((t) => t.task_id);
+                return q
+                    .raw(taskIds.length > 0
+                    ? `SELECT task_id, domain FROM \`task_domain\` WHERE task_id IN (${taskIds.map((id) => `'${(0, escape_1.sqlEscape)(id)}'`).join(",")})`
+                    : "SELECT task_id, domain FROM `task_domain` WHERE 1=0")
+                    .andThen((domainRows) => q
+                    .raw(taskIds.length > 0 ? `SELECT task_id, skill FROM \`task_skill\` WHERE task_id IN (${taskIds.map((id) => `'${(0, escape_1.sqlEscape)(id)}'`).join(",")})` : "SELECT task_id, skill FROM `task_skill` WHERE 1=0")
+                    .map((skillRows) => {
+                    const domainsByTask = new Map();
+                    domainRows.forEach((r) => {
+                        const arr = domainsByTask.get(r.task_id) ?? [];
+                        arr.push(r.domain);
+                        domainsByTask.set(r.task_id, arr);
+                    });
+                    const skillsByTask = new Map();
+                    skillRows.forEach((r) => {
+                        const arr = skillsByTask.get(r.task_id) ?? [];
+                        arr.push(r.skill);
+                        skillsByTask.set(r.task_id, arr);
+                    });
+                    return { domainsByTask, skillsByTask };
+                }))
+                    .andThen(({ domainsByTask, skillsByTask }) => q
+                    .raw("SELECT from_task_id, to_task_id, type FROM `edge` WHERE type = 'blocks'")
+                    .map((edges) => {
+                    const taskIdToKey = new Map();
+                    tasks.forEach((t) => {
+                        if (t.external_key) {
+                            taskIdToKey.set(t.task_id, t.external_key);
+                        }
+                    });
+                    const blockedByMap = new Map();
+                    edges.forEach((e) => {
+                        if (e.to_task_id &&
+                            taskIdToKey.has(e.from_task_id) &&
+                            taskIdToKey.has(e.to_task_id)) {
+                            const key = taskIdToKey.get(e.to_task_id);
+                            const blockerKey = taskIdToKey.get(e.from_task_id);
+                            if (!blockedByMap.has(key)) {
+                                blockedByMap.set(key, []);
+                            }
+                            blockedByMap.get(key).push(blockerKey);
+                        }
+                    });
+                    const todos = tasks
+                        .filter((t) => t.external_key)
+                        .map((t) => {
+                        const status = t.status === "done" ? "completed" : "pending";
+                        const blockedBy = blockedByMap.get(t.external_key) ?? [];
+                        const domains = domainsByTask.get(t.task_id);
+                        const skills = skillsByTask.get(t.task_id);
+                        return {
+                            id: t.external_key,
+                            content: t.title,
+                            status,
+                            ...(blockedBy.length > 0 && { blockedBy }),
+                            ...(domains &&
+                                domains.length > 0 && { domain: domains }),
+                            ...(skills && skills.length > 0 && { skill: skills }),
+                        };
+                    });
+                    const frontmatter = {
+                        name: plan.title,
+                        overview: plan.intent || "",
+                        todos,
+                        isProject: false,
+                    };
+                    const yamlStr = js_yaml_1.default.dump(frontmatter, { lineWidth: -1 });
+                    return `---
+${yamlStr}---
+`;
+                }));
+            });
+        });
+    });
+}

package/dist/export/mermaid.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMermaidGraph = formatMermaidGraph;
+exports.generateMermaidGraph = generateMermaidGraph;
+const graph_data_1 = require("./graph-data");
+function formatMermaidGraph(nodes, edges) {
+    let mermaid = "graph TD\n";
+    nodes.forEach((node) => {
+        // Node IDs in Mermaid typically cannot have special characters or spaces
+        const nodeId = node.id.replace(/[^a-zA-Z0-9]/g, "");
+        mermaid += `  ${nodeId}[\"${node.label}\"]\n`;
+    });
+    edges.forEach((edge) => {
+        const fromNodeId = edge.from.replace(/[^a-zA-Z0-9]/g, "");
+        const toNodeId = edge.to.replace(/[^a-zA-Z0-9]/g, "");
+        if (edge.type === "blocks") {
+            mermaid += `  ${fromNodeId} --> ${toNodeId}\n`;
+        }
+        else if (edge.type === "relates") {
+            mermaid += `  ${fromNodeId} --- ${toNodeId}\n`;
+        }
+    });
+    return mermaid;
+}
+function generateMermaidGraph(planId, featureKey, basePath) {
+    return (0, graph_data_1.getGraphData)(planId, featureKey, basePath).map(({ nodes, edges }) => formatMermaidGraph(nodes, edges));
+}