@danalexilewis/taskgraph 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 danalexilewis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# Taskgraph
+
+Inspired by [Beads](https://github.com/steveyegge/beads) and [Gastown.dev](https://gastown.dev) — Task Graph is for **Centaur Development** (human + agent).
+
+## Why this repo
+
+I wanted a small, local-first way to manage plans and tasks during agent-assisted coding without adopting full Beads/Gastown orchestration. Task-Graph borrows from Beads (atomic claims, structured notes, status visibility) but stays minimal: one working copy, no mayor/orchestrator, no swarms. It’s a Dolt-backed CLI that fits into Cursor workflows so agents and humans can share the same task graph and execution state.
+
+## What this is
+
+TaskGraph is a small CLI (`tg`) + Dolt-backed schema for managing **plans, tasks, dependencies, and execution state** during agent-assisted (“centaur”) development.
+
+## Quick start
+
+1. Install Dolt (`brew install dolt`)
+2. Initialize TaskGraph in your repo:
+
+```bash
+tg init
+```
+
+1. Scaffold recommended conventions (example domain docs, skill guides, and Cursor rules):
+
+```bash
+tg setup
+```
+
+## Conventions (domain + skill guides)
+
+Tasks can optionally declare:
+
+- `domain`: slug(s) that map to `docs/<domain>.md`
+- `skill`: slug(s) that map to `docs/skills/<skill>.md`
+
+Agents can read the docs printed by `tg context <taskId>` to load repo-specific conventions before making changes.
+
+## Publishing the CLI to npm
+
+The repo root is the publishable package. **Run from the repo root**:
+
+1. **Package name**: The name `taskgraph` is available. If it were taken, use a scoped name in `package.json` (e.g. `@yourname/taskgraph`).
+2. **Build**: `pnpm build`
+3. **Dry-run** (see what will be in the tarball): `npm pack --dry-run`
+4. **Publish**: `npm publish`  
+   (Requires `npm login` and 2FA if enabled.)
+
+The `prepublishOnly` script runs `npm run build` when you publish, so `dist/` is built before packing. The tarball includes only `dist`, `templates`, and `README.md` (see `files` in package.json).

package/dist/cli/block.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blockCommand = blockCommand;
+const uuid_1 = require("uuid");
+const commit_1 = require("../db/commit");
+const utils_1 = require("./utils"); // Import Config
+const invariants_1 = require("../domain/invariants");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+function blockCommand(program) {
+    program
+        .command("block")
+        .description("Block a task on another task")
+        .argument("<taskId>", "ID of the task to be blocked")
+        .requiredOption("--on <blockerTaskId>", "ID of the task that is blocking")
+        .option("--reason <reason>", "Reason for the block")
+        .action(async (taskId, options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            // Removed async, added type
+            const currentTimestamp = (0, query_1.now)();
+            const q = (0, query_1.query)(config.doltRepoPath);
+            return neverthrow_1.ResultAsync.fromPromise((async () => {
+                const existingEdgesResult = await q.select("edge", {
+                    where: { type: "blocks" },
+                });
+                if (existingEdgesResult.isErr())
+                    throw existingEdgesResult.error;
+                const existingEdges = existingEdgesResult.value;
+                const cycleCheckResult = (0, invariants_1.checkNoBlockerCycle)(options.on, taskId, existingEdges);
+                if (cycleCheckResult.isErr())
+                    throw cycleCheckResult.error;
+                const edgeExistsResult = await q.count("edge", {
+                    from_task_id: options.on,
+                    to_task_id: taskId,
+                    type: "blocks",
+                });
+                if (edgeExistsResult.isErr())
+                    throw edgeExistsResult.error;
+                const edgeExists = edgeExistsResult.value;
+                if (edgeExists === 0) {
+                    const insertResult = await q.insert("edge", {
+                        from_task_id: options.on,
+                        to_task_id: taskId,
+                        type: "blocks",
+                        reason: options.reason ?? null,
+                    });
+                    if (insertResult.isErr())
+                        throw insertResult.error;
+                }
+                else {
+                    console.log(`Edge from ${options.on} to ${taskId} of type 'blocks' already exists. Skipping edge creation.`);
+                }
+                const currentStatusResult = await q.select("task", { columns: ["status"], where: { task_id: taskId } });
+                if (currentStatusResult.isErr())
+                    throw currentStatusResult.error;
+                if (currentStatusResult.value.length === 0) {
+                    throw (0, errors_1.buildError)(errors_1.ErrorCode.TASK_NOT_FOUND, `Task with ID ${taskId} not found.`);
+                }
+                const currentStatus = currentStatusResult.value[0].status;
+                if (currentStatus !== "blocked") {
+                    const transitionResult = (0, invariants_1.checkValidTransition)(currentStatus, "blocked");
+                    if (transitionResult.isErr())
+                        throw transitionResult.error;
+                    const updateStatusResult = await q.update("task", { status: "blocked", updated_at: currentTimestamp }, { task_id: taskId });
+                    if (updateStatusResult.isErr())
+                        throw updateStatusResult.error;
+                }
+                const insertEventResult = await q.insert("event", {
+                    event_id: (0, uuid_1.v4)(),
+                    task_id: taskId,
+                    kind: "blocked",
+                    body: (0, query_1.jsonObj)({
+                        blockerTaskId: options.on,
+                        reason: options.reason ?? null,
+                        timestamp: currentTimestamp,
+                    }),
+                    created_at: currentTimestamp,
+                });
+                if (insertEventResult.isErr())
+                    throw insertEventResult.error;
+                const commitResult = await (0, commit_1.doltCommit)(`task: block ${taskId} on ${options.on}`, config.doltRepoPath, cmd.parent?.opts().noCommit);
+                if (commitResult.isErr())
+                    throw commitResult.error;
+                return {
+                    task_id: taskId,
+                    blocker_task_id: options.on,
+                    reason: options.reason,
+                    status: "blocked",
+                };
+            })(), (e) => e);
+        });
+        result.match((data) => {
+            const resultData = data;
+            if (!cmd.parent?.opts().json) {
+                console.log(`Task ${resultData.task_id} blocked by ${resultData.blocker_task_id}.`);
+            }
+            else {
+                console.log(JSON.stringify(resultData, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error blocking task: ${error.message}`);
+            if (cmd.parent?.opts().json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/cli/context.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextCommand = contextCommand;
+const utils_1 = require("./utils");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+const escape_1 = require("../db/escape");
+function contextCommand(program) {
+    program
+        .command("context")
+        .description("Output domain doc paths, skill guide paths, and related done tasks for a task (run before starting work)")
+        .argument("<taskId>", "Task ID")
+        .action(async (taskId, options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            const q = (0, query_1.query)(config.doltRepoPath);
+            return q
+                .select("task", {
+                columns: [
+                    "task_id",
+                    "title",
+                    "change_type",
+                    "plan_id",
+                    "suggested_changes",
+                ],
+                where: { task_id: taskId },
+            })
+                .andThen((taskRows) => {
+                if (taskRows.length === 0) {
+                    return (0, neverthrow_1.errAsync)((0, errors_1.buildError)(errors_1.ErrorCode.TASK_NOT_FOUND, `Task ${taskId} not found`));
+                }
+                const task = taskRows[0];
+                return q
+                    .select("plan", {
+                    columns: ["file_tree", "risks"],
+                    where: { plan_id: task.plan_id },
+                })
+                    .andThen((planRows) => {
+                    const plan = planRows[0];
+                    const file_tree = plan?.file_tree ?? null;
+                    let risks = null;
+                    if (plan?.risks != null && typeof plan.risks === "string") {
+                        try {
+                            risks = JSON.parse(plan.risks);
+                        }
+                        catch {
+                            risks = null;
+                        }
+                    }
+                    return q
+                        .select("task_domain", {
+                        columns: ["domain"],
+                        where: { task_id: taskId },
+                    })
+                        .andThen((domainRows) => q
+                        .select("task_skill", {
+                        columns: ["skill"],
+                        where: { task_id: taskId },
+                    })
+                        .map((skillRows) => ({
+                        task,
+                        file_tree,
+                        risks,
+                        domains: domainRows.map((r) => r.domain),
+                        skills: skillRows.map((r) => r.skill),
+                    })));
+                });
+            })
+                .andThen(({ task, file_tree, risks, domains, skills }) => {
+                const domain_docs = domains.map((d) => `docs/${d}.md`);
+                const skill_docs = skills.map((s) => `docs/skills/${s}.md`);
+                const relatedByDomainSql = domains.length > 0
+                    ? `SELECT DISTINCT t.task_id, t.title, t.plan_id FROM \`task\` t JOIN \`task_domain\` td ON t.task_id = td.task_id WHERE t.status = 'done' AND t.task_id != '${(0, escape_1.sqlEscape)(taskId)}' AND td.domain IN (${domains.map((d) => `'${(0, escape_1.sqlEscape)(d)}'`).join(",")}) ORDER BY t.updated_at DESC LIMIT 5`
+                    : null;
+                const relatedBySkillSql = skills.length > 0
+                    ? `SELECT DISTINCT t.task_id, t.title, t.plan_id FROM \`task\` t JOIN \`task_skill\` ts ON t.task_id = ts.task_id WHERE t.status = 'done' AND t.task_id != '${(0, escape_1.sqlEscape)(taskId)}' AND ts.skill IN (${skills.map((s) => `'${(0, escape_1.sqlEscape)(s)}'`).join(",")}) ORDER BY t.updated_at DESC LIMIT 5`
+                    : null;
+                const runDomain = relatedByDomainSql
+                    ? q.raw(relatedByDomainSql)
+                    : neverthrow_1.ResultAsync.fromSafePromise(Promise.resolve([]));
+                const runSkill = relatedBySkillSql
+                    ? q.raw(relatedBySkillSql)
+                    : neverthrow_1.ResultAsync.fromSafePromise(Promise.resolve([]));
+                return runDomain.andThen((relatedByDomain) => runSkill.map((relatedBySkill) => ({
+                    task_id: task.task_id,
+                    title: task.title,
+                    domains,
+                    skills,
+                    change_type: task.change_type ?? null,
+                    suggested_changes: task.suggested_changes ?? null,
+                    file_tree,
+                    risks,
+                    domain_docs,
+                    skill_docs,
+                    related_done_by_domain: relatedByDomain,
+                    related_done_by_skill: relatedBySkill,
+                })));
+            });
+        });
+        result.match((data) => {
+            const d = data;
+            if ((0, utils_1.rootOpts)(cmd).json) {
+                console.log(JSON.stringify(d, null, 2));
+                return;
+            }
+            console.log(`Task: ${d.title} (${d.task_id})`);
+            if (d.change_type)
+                console.log(`Change type: ${d.change_type}`);
+            d.domain_docs.forEach((doc) => console.log(`Domain doc: ${doc}`));
+            d.skill_docs.forEach((doc) => console.log(`Skill guide: ${doc}`));
+            if (d.suggested_changes) {
+                console.log(`Suggested changes:`);
+                console.log(d.suggested_changes);
+            }
+            if (d.file_tree) {
+                console.log(`Plan file tree:`);
+                console.log(d.file_tree);
+            }
+            if (d.risks != null && Array.isArray(d.risks) && d.risks.length > 0) {
+                console.log(`Plan risks:`);
+                d.risks.forEach((r) => console.log(`  - ${r.severity ?? "?"}: ${r.description ?? ""} (${r.mitigation ?? ""})`));
+            }
+            if (d.related_done_by_domain.length > 0) {
+                console.log(`Related done (same domain):`);
+                d.related_done_by_domain.forEach((t) => console.log(`  ${t.task_id}  ${t.title}`));
+            }
+            if (d.related_done_by_skill.length > 0) {
+                console.log(`Related done (same skill):`);
+                d.related_done_by_skill.forEach((t) => console.log(`  ${t.task_id}  ${t.title}`));
+            }
+        }, (error) => {
+            console.error(`Error: ${error.message}`);
+            if ((0, utils_1.rootOpts)(cmd).json) {
+                console.log(JSON.stringify({ status: "error", message: error.message }, null, 2));
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/cli/done.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doneCommand = doneCommand;
+const uuid_1 = require("uuid");
+const commit_1 = require("../db/commit");
+const utils_1 = require("./utils"); // Import Config
+const invariants_1 = require("../domain/invariants");
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../domain/errors");
+const query_1 = require("../db/query");
+function doneCommand(program) {
+    program
+        .command("done")
+        .description("Mark a task as done")
+        .argument("<taskId>", "ID of the task to mark as done")
+        .option("--evidence <text>", "Evidence of completion", "")
+        .option("--checks <json>", "JSON array of acceptance checks")
+        .option("--force", "Allow marking as done even if not in 'doing' status", false)
+        .action(async (taskId, options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            // Removed async, added type
+            const currentTimestamp = (0, query_1.now)();
+            const q = (0, query_1.query)(config.doltRepoPath);
+            return q
+                .select("task", {
+                columns: ["status"],
+                where: { task_id: taskId },
+            })
+                .andThen((currentStatusResult) => {
+                if (currentStatusResult.length === 0) {
+                    return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.TASK_NOT_FOUND, `Task with ID ${taskId} not found.`));
+                }
+                const currentStatus = currentStatusResult[0].status;
+                if (!options.force) {
+                    const transitionResult = (0, invariants_1.checkValidTransition)(currentStatus, "done");
+                    if (transitionResult.isErr())
+                        return (0, neverthrow_1.err)(transitionResult.error);
+                }
+                return (0, neverthrow_1.ok)(currentStatus);
+            })
+                .andThen(() => q.update("task", { status: "done", updated_at: currentTimestamp }, { task_id: taskId }))
+                .andThen(() => {
+                let parsedChecks = null;
+                if (options.checks) {
+                    try {
+                        parsedChecks = JSON.parse(options.checks);
+                    }
+                    catch (e) {
+                        return (0, neverthrow_1.err)((0, errors_1.buildError)(errors_1.ErrorCode.VALIDATION_FAILED, `Invalid JSON for acceptance checks: ${options.checks}`, e));
+                    }
+                }
+                const eventBody = {
+                    evidence: options.evidence,
+                    checks: parsedChecks,
+                    timestamp: currentTimestamp,
+                };
+                return q.insert("event", {
+                    event_id: (0, uuid_1.v4)(),
+                    task_id: taskId,
+                    kind: "done",
+                    body: (0, query_1.jsonObj)({
+                        evidence: eventBody.evidence,
+                        checks: eventBody.checks,
+                        timestamp: eventBody.timestamp,
+                    }),
+                    created_at: currentTimestamp,
+                });
+            })
+                .andThen(() => (0, commit_1.doltCommit)(`task: done ${taskId}`, config.doltRepoPath, cmd.parent?.opts().noCommit))
+                .map(() => ({
+                task_id: taskId,
+                status: "done",
+                evidence: options.evidence,
+                checks: options.checks,
+            }));
+        });
+        result.match((data) => {
+            const resultData = data;
+            if (!cmd.parent?.opts().json) {
+                console.log(`Task ${resultData.task_id} marked as done.`);
+            }
+            else {
+                console.log(JSON.stringify(resultData, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error marking task ${taskId} as done: ${error.message}`);
+            if (cmd.parent?.opts().json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/cli/edge.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.edgeCommand = edgeCommand;
+const commander_1 = require("commander");
+const commit_1 = require("../db/commit");
+const utils_1 = require("./utils");
+const types_1 = require("../domain/types");
+const neverthrow_1 = require("neverthrow");
+const invariants_1 = require("../domain/invariants");
+const query_1 = require("../db/query");
+function edgeCommand(program) {
+    program
+        .command("edge")
+        .description("Manage task dependencies")
+        .addCommand(edgeAddCommand());
+}
+function edgeAddCommand() {
+    return new commander_1.Command("add")
+        .description("Add a dependency edge between tasks")
+        .argument("<fromTaskId>", "ID of the blocking task")
+        .argument("<type>", "Type of edge (blocks or relates)", (value) => {
+        const parsed = types_1.EdgeTypeSchema.safeParse(value);
+        if (!parsed.success) {
+            throw new Error(`Invalid edge type: ${value}. Must be one of: ${types_1.EdgeTypeSchema.options.join(", ")}`);
+        }
+        return value;
+    })
+        .argument("<toTaskId>", "ID of the blocked task")
+        .option("--reason <reason>", "Reason for the dependency")
+        .action(async (fromTaskId, type, toTaskId, options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            const q = (0, query_1.query)(config.doltRepoPath);
+            if (type === "blocks") {
+                return neverthrow_1.ResultAsync.fromPromise((async () => {
+                    const existingEdgesResult = await q.select("edge", {
+                        where: { type: "blocks" },
+                    });
+                    if (existingEdgesResult.isErr()) {
+                        throw existingEdgesResult.error;
+                    }
+                    const existingEdges = existingEdgesResult.value;
+                    const cycleCheckResult = (0, invariants_1.checkNoBlockerCycle)(fromTaskId, toTaskId, existingEdges);
+                    if (cycleCheckResult.isErr())
+                        throw cycleCheckResult.error;
+                    return (0, neverthrow_1.ok)(undefined); // Return an Ok Result to continue the chain
+                })(), (e) => e).andThen(() => {
+                    // Continue the original chain here after cycle check
+                    return q
+                        .insert("edge", {
+                        from_task_id: fromTaskId,
+                        to_task_id: toTaskId,
+                        type,
+                        reason: options.reason ?? null,
+                    })
+                        .map(() => ({
+                        from_task_id: fromTaskId,
+                        to_task_id: toTaskId,
+                        type,
+                        reason: options.reason,
+                    }));
+                });
+            }
+            return q
+                .insert("edge", {
+                from_task_id: fromTaskId,
+                to_task_id: toTaskId,
+                type,
+                reason: options.reason ?? null,
+            })
+                .andThen(() => (0, commit_1.doltCommit)(`edge: add ${fromTaskId} ${type} ${toTaskId}`, config.doltRepoPath, cmd.parent?.opts().noCommit))
+                .map(() => ({
+                from_task_id: fromTaskId,
+                to_task_id: toTaskId,
+                type,
+                reason: options.reason,
+            }));
+        });
+        result.match((data) => {
+            const resultData = data;
+            if (!cmd.parent?.opts().json) {
+                console.log(`Edge added: ${resultData.from_task_id} ${resultData.type} ${resultData.to_task_id}`);
+            }
+            else {
+                console.log(JSON.stringify(resultData, null, 2));
+            }
+        }, (error) => {
+            console.error(`Error adding edge: ${error.message}`);
+            if (cmd.parent?.opts().json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}

package/dist/cli/export.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportCommand = exportCommand;
+const commander_1 = require("commander");
+const fs_1 = require("fs");
+const mermaid_1 = require("../export/mermaid");
+const dot_1 = require("../export/dot");
+const markdown_1 = require("../export/markdown");
+const utils_1 = require("./utils");
+function exportCommand(program) {
+    program
+        .command("export")
+        .description("Export graph visualizations and markdown")
+        .addCommand(exportMermaidCommand())
+        .addCommand(exportDotCommand())
+        .addCommand(exportMarkdownCommand());
+}
+function exportMermaidCommand() {
+    return new commander_1.Command("mermaid")
+        .description("Output Mermaid graph TD text to stdout")
+        .option("--plan <planId>", "Filter by plan ID")
+        .option("--feature <featureKey>", "Filter by feature key")
+        .action(async (options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            // Removed config.doltRepoPath from generateMermaidGraph call
+            return (0, mermaid_1.generateMermaidGraph)(options.plan, options.feature);
+        });
+        result.match((mermaidGraph) => {
+            console.log(mermaidGraph);
+        }, (error) => {
+            console.error(`Error generating Mermaid graph: ${error.message}`);
+            if (cmd.parent?.opts().json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}
+function exportDotCommand() {
+    return new commander_1.Command("dot")
+        .description("Output Graphviz DOT text to stdout")
+        .option("--plan <planId>", "Filter by plan ID")
+        .option("--feature <featureKey>", "Filter by feature key")
+        .action(async (options, cmd) => {
+        const result = await (0, utils_1.readConfig)().asyncAndThen((config) => {
+            // Removed config.doltRepoPath from generateDotGraph call
+            return (0, dot_1.generateDotGraph)(options.plan, options.feature);
+        });
+        result.match((dotGraph) => {
+            console.log(dotGraph);
+        }, (error) => {
+            console.error(`Error generating DOT graph: ${error.message}`);
+            if (cmd.parent?.opts().json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}
+function exportMarkdownCommand() {
+    return new commander_1.Command("markdown")
+        .description("Output plan and tasks in Cursor format (for round-trip import)")
+        .requiredOption("--plan <planId>", "Plan ID to export")
+        .option("--out <path>", "Write to file instead of stdout")
+        .action(async (options, cmd) => {
+        const result = await (0, markdown_1.generateMarkdown)(options.plan);
+        result.match((markdown) => {
+            if (options.out) {
+                (0, fs_1.writeFileSync)(options.out, markdown);
+            }
+            else {
+                console.log(markdown);
+            }
+        }, (error) => {
+            console.error(`Error exporting markdown: ${error.message}`);
+            if (cmd.parent?.opts().json) {
+                console.log(JSON.stringify({
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    cause: error.cause,
+                }));
+            }
+            process.exit(1);
+        });
+    });
+}