mdkg 0.0.1 → 0.0.2

package/dist/commands/new.js

@@ -0,0 +1,279 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNewCommand = runNewCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../core/config");
+const index_cache_1 = require("../graph/index_cache");
+const node_1 = require("../graph/node");
+const indexer_1 = require("../graph/indexer");
+const loader_1 = require("../templates/loader");
+const date_1 = require("../util/date");
+const errors_1 = require("../util/errors");
+const qid_1 = require("../util/qid");
+const ID_RE = /^[a-z]+-[0-9]+$/;
+const ID_REF_RE = /^([a-z][a-z0-9_]*:)?[a-z]+-[0-9]+$/;
+const DEC_ID_RE = /^dec-[0-9]+$/;
+const DEC_STATUS = new Set(["proposed", "accepted", "rejected", "superseded"]);
+const CORE_TYPES = new Set(["rule"]);
+const DESIGN_TYPES = new Set(["prd", "edd", "dec", "prop"]);
+function parseCsvList(raw) {
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+}
+function normalizeId(value, key) {
+    const normalized = value.toLowerCase();
+    if (!ID_RE.test(normalized) && normalized !== "rule-guide") {
+        throw new errors_1.UsageError(`${key} entries must match <prefix>-<number>: ${value}`);
+    }
+    return normalized;
+}
+function normalizeIdRef(value, key) {
+    const normalized = value.toLowerCase();
+    if (!ID_REF_RE.test(normalized)) {
+        throw new errors_1.UsageError(`${key} entries must match <id> or <ws>:<id>: ${value}`);
+    }
+    return normalized;
+}
+function normalizeList(raw) {
+    return parseCsvList(raw);
+}
+function normalizeLowercaseList(raw) {
+    return parseCsvList(raw).map((value) => value.toLowerCase());
+}
+function normalizeIdList(raw, key) {
+    return parseCsvList(raw).map((value) => normalizeId(value, key));
+}
+function normalizeIdRefList(raw, key) {
+    return parseCsvList(raw).map((value) => normalizeIdRef(value, key));
+}
+function normalizeWorkspace(value) {
+    if (!value) {
+        return "root";
+    }
+    const normalized = value.toLowerCase();
+    if (normalized === "all") {
+        throw new errors_1.UsageError("--ws all is not valid for creation");
+    }
+    return normalized;
+}
+function slugifyTitle(title) {
+    const slug = title
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-+/g, "-");
+    if (!slug) {
+        return "node";
+    }
+    const maxLen = 80;
+    return slug.length > maxLen ? slug.slice(0, maxLen).replace(/-+$/g, "") : slug;
+}
+function nextIdForPrefix(index, ws, prefix) {
+    let max = 0;
+    const pattern = new RegExp(`^${prefix}-(\\d+)$`);
+    for (const node of Object.values(index)) {
+        if (node.ws !== ws) {
+            continue;
+        }
+        const match = pattern.exec(node.id);
+        if (!match) {
+            continue;
+        }
+        const parsed = Number.parseInt(match[1] ?? "", 10);
+        if (Number.isInteger(parsed) && parsed > max) {
+            max = parsed;
+        }
+    }
+    return `${prefix}-${max + 1}`;
+}
+function idPrefixForType(type) {
+    if (type === "checkpoint") {
+        return "chk";
+    }
+    return type;
+}
+function folderForType(type) {
+    if (CORE_TYPES.has(type)) {
+        return "core";
+    }
+    if (DESIGN_TYPES.has(type)) {
+        return "design";
+    }
+    if (node_1.WORK_TYPES.has(type)) {
+        return "work";
+    }
+    throw new errors_1.UsageError(`unsupported type: ${type}`);
+}
+function ensureExists(index, value, ws, label) {
+    const resolved = (0, qid_1.resolveQid)(index, value, ws);
+    if (resolved.status !== "ok") {
+        throw new errors_1.NotFoundError((0, qid_1.formatResolveError)(label, value, resolved, ws));
+    }
+}
+function runNewCommand(options) {
+    const title = options.title.trim();
+    if (!title) {
+        throw new errors_1.UsageError("title cannot be empty");
+    }
+    const type = options.type.toLowerCase();
+    if (!node_1.ALLOWED_TYPES.has(type)) {
+        throw new errors_1.UsageError(`type must be one of ${Array.from(node_1.ALLOWED_TYPES).join(", ")}`);
+    }
+    const config = (0, config_1.loadConfig)(options.root);
+    const ws = normalizeWorkspace(options.ws);
+    if (!config.workspaces[ws]) {
+        throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
+    }
+    const noCache = Boolean(options.noCache);
+    const noReindex = Boolean(options.noReindex);
+    const { index } = (0, index_cache_1.loadIndex)({
+        root: options.root,
+        config,
+        useCache: !noCache,
+        allowReindex: !noReindex,
+    });
+    const prefix = idPrefixForType(type);
+    const id = nextIdForPrefix(index.nodes, ws, prefix);
+    const slug = slugifyTitle(title);
+    const fileName = `${id}-${slug}.md`;
+    const wsEntry = config.workspaces[ws];
+    const folder = folderForType(type);
+    const targetDir = path_1.default.resolve(options.root, wsEntry.path, wsEntry.mdkg_dir, folder);
+    const filePath = path_1.default.join(targetDir, fileName);
+    if (fs_1.default.existsSync(filePath)) {
+        throw new errors_1.UsageError(`node already exists: ${path_1.default.relative(options.root, filePath)}`);
+    }
+    const statusInput = options.status?.toLowerCase();
+    let status;
+    if (node_1.WORK_TYPES.has(type)) {
+        const allowed = new Set(config.work.status_enum.map((value) => value.toLowerCase()));
+        status = statusInput ?? config.work.status_enum[0]?.toLowerCase();
+        if (!status || !allowed.has(status)) {
+            throw new errors_1.UsageError(`--status must be one of ${Array.from(allowed).join(", ")}`);
+        }
+    }
+    else if (type === "dec") {
+        status = statusInput ?? "proposed";
+        if (!DEC_STATUS.has(status)) {
+            throw new errors_1.UsageError(`--status must be one of ${Array.from(DEC_STATUS).join(", ")}`);
+        }
+    }
+    else if (statusInput) {
+        throw new errors_1.UsageError("--status is only valid for work items and decisions");
+    }
+    let priority;
+    if (node_1.WORK_TYPES.has(type)) {
+        if (options.priority !== undefined) {
+            priority = options.priority;
+        }
+        else {
+            priority = config.work.priority_max;
+        }
+        if (!Number.isInteger(priority) || priority < config.work.priority_min || priority > config.work.priority_max) {
+            throw new errors_1.UsageError(`--priority must be between ${config.work.priority_min} and ${config.work.priority_max}`);
+        }
+    }
+    else if (options.priority !== undefined) {
+        throw new errors_1.UsageError("--priority is only valid for work items");
+    }
+    if (!node_1.WORK_TYPES.has(type)) {
+        if (options.epic || options.parent || options.prev || options.next || options.blockedBy || options.blocks) {
+            throw new errors_1.UsageError("epic/parent/prev/next/blocked-by/blocks are only valid for work items");
+        }
+    }
+    if (options.cases && type !== "test") {
+        throw new errors_1.UsageError("--cases is only valid for test nodes");
+    }
+    const epic = options.epic ? normalizeIdRef(options.epic, "--epic") : undefined;
+    const parent = options.parent ? normalizeIdRef(options.parent, "--parent") : undefined;
+    const prev = options.prev ? normalizeIdRef(options.prev, "--prev") : undefined;
+    const next = options.next ? normalizeIdRef(options.next, "--next") : undefined;
+    const relates = normalizeIdRefList(options.relates, "--relates");
+    const blockedBy = normalizeIdRefList(options.blockedBy, "--blocked-by");
+    const blocks = normalizeIdRefList(options.blocks, "--blocks");
+    const refs = normalizeIdList(options.refs, "--refs");
+    const aliases = normalizeLowercaseList(options.aliases);
+    const tags = normalizeLowercaseList(options.tags);
+    const owners = normalizeLowercaseList(options.owners);
+    const cases = normalizeLowercaseList(options.cases);
+    const links = normalizeList(options.links);
+    const artifacts = normalizeList(options.artifacts);
+    if (type === "dec" && options.supersedes) {
+        const supersedes = options.supersedes.toLowerCase();
+        if (!DEC_ID_RE.test(supersedes)) {
+            throw new errors_1.UsageError("--supersedes must be a dec-# id");
+        }
+    }
+    else if (options.supersedes && type !== "dec") {
+        throw new errors_1.UsageError("--supersedes is only valid for dec records");
+    }
+    const idRefsToCheck = [];
+    if (epic) {
+        idRefsToCheck.push(["epic", epic]);
+    }
+    if (parent) {
+        idRefsToCheck.push(["parent", parent]);
+    }
+    if (prev) {
+        idRefsToCheck.push(["prev", prev]);
+    }
+    if (next) {
+        idRefsToCheck.push(["next", next]);
+    }
+    for (const value of relates) {
+        idRefsToCheck.push(["relates", value]);
+    }
+    for (const value of blockedBy) {
+        idRefsToCheck.push(["blocked_by", value]);
+    }
+    for (const value of blocks) {
+        idRefsToCheck.push(["blocks", value]);
+    }
+    for (const [label, value] of idRefsToCheck) {
+        ensureExists(index, value, ws, label);
+    }
+    const today = (0, date_1.formatDate)(options.now ?? new Date());
+    const template = (0, loader_1.loadTemplate)(options.root, config, type, options.template);
+    const content = (0, loader_1.renderTemplate)(template, {
+        id,
+        type,
+        title,
+        status,
+        priority,
+        epic,
+        parent,
+        prev,
+        next,
+        relates: relates.length > 0 ? relates : undefined,
+        blocked_by: blockedBy.length > 0 ? blockedBy : undefined,
+        blocks: blocks.length > 0 ? blocks : undefined,
+        tags: tags.length > 0 ? tags : undefined,
+        owners: owners.length > 0 ? owners : undefined,
+        links: links.length > 0 ? links : undefined,
+        artifacts: artifacts.length > 0 ? artifacts : undefined,
+        refs: refs.length > 0 ? refs : undefined,
+        aliases: aliases.length > 0 ? aliases : undefined,
+        cases: cases.length > 0 ? cases : undefined,
+        supersedes: options.supersedes ? options.supersedes.toLowerCase() : undefined,
+        created: today,
+        updated: today,
+    });
+    fs_1.default.mkdirSync(targetDir, { recursive: true });
+    fs_1.default.writeFileSync(filePath, content, "utf8");
+    if (config.index.auto_reindex && !noReindex) {
+        const updatedIndex = (0, indexer_1.buildIndex)(options.root, config, { tolerant: config.index.tolerant });
+        const outputPath = path_1.default.resolve(options.root, config.index.global_index_path);
+        (0, index_cache_1.writeIndex)(outputPath, updatedIndex);
+    }
+    console.log(`node created: ${ws}:${id} (${path_1.default.relative(options.root, filePath)})`);
+}

package/dist/commands/next.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNextCommand = runNextCommand;
+const config_1 = require("../core/config");
+const index_cache_1 = require("../graph/index_cache");
+const errors_1 = require("../util/errors");
+const qid_1 = require("../util/qid");
+const sort_1 = require("../util/sort");
+const node_card_1 = require("./node_card");
+const NEXT_TYPES = new Set(["feat", "task", "bug", "test"]);
+const NO_MATCH_MESSAGE = 'no matching work items found; consider `mdkg new task "..."` or `mdkg new test "..."`';
+function normalizeWorkspace(value) {
+    if (!value || value === "all") {
+        return undefined;
+    }
+    return value;
+}
+function selectNextByPriority(index, ws, statusPreference, priorityMax) {
+    const statusRanks = new Set(statusPreference);
+    const candidates = Object.values(index.nodes).filter((node) => {
+        if (ws && node.ws !== ws) {
+            return false;
+        }
+        if (!NEXT_TYPES.has(node.type)) {
+            return false;
+        }
+        if (!node.status) {
+            return false;
+        }
+        if (!statusRanks.has(node.status)) {
+            return false;
+        }
+        return true;
+    });
+    const sorted = (0, sort_1.sortNodesForNext)(candidates, {
+        statusPreference,
+        priorityMax,
+    });
+    return sorted[0];
+}
+function runNextCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const ws = normalizeWorkspace(options.ws);
+    if (ws && !config.workspaces[ws]) {
+        throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
+    }
+    const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
+        root: options.root,
+        config,
+        useCache: !options.noCache,
+        allowReindex: !options.noReindex,
+    });
+    if (stale && !rebuilt && !options.noCache) {
+        console.error("warning: index is stale; run mdkg index to refresh");
+    }
+    if (options.id) {
+        const resolved = (0, qid_1.resolveQid)(index, options.id, ws);
+        if (resolved.status !== "ok") {
+            throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("id", options.id, resolved, ws));
+        }
+        const node = index.nodes[resolved.qid];
+        const nextQid = node.edges.next;
+        if (nextQid && index.nodes[nextQid]) {
+            console.log((0, node_card_1.formatNodeCard)(index.nodes[nextQid]));
+            return;
+        }
+    }
+    const statusPreference = config.work.next.status_preference.map((status) => status.toLowerCase());
+    const selected = selectNextByPriority(index, ws, statusPreference, config.work.priority_max);
+    if (!selected) {
+        console.error(NO_MATCH_MESSAGE);
+        return;
+    }
+    console.log((0, node_card_1.formatNodeCard)(selected));
+}

package/dist/commands/node_card.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatNodeCard = formatNodeCard;
+function formatStatusPriority(node) {
+    const status = node.status ?? "-";
+    const priority = node.priority === undefined ? "-" : `p${node.priority}`;
+    return `${status}/${priority}`;
+}
+function formatNodeCard(node) {
+    return [
+        node.qid,
+        node.type,
+        formatStatusPriority(node),
+        node.title,
+        node.path,
+    ].join(" | ");
+}

package/dist/commands/pack.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPackCommand = runPackCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../core/config");
+const index_cache_1 = require("../graph/index_cache");
+const errors_1 = require("../util/errors");
+const qid_1 = require("../util/qid");
+const output_1 = require("../util/output");
+const pack_1 = require("../pack/pack");
+const export_md_1 = require("../pack/export_md");
+const export_json_1 = require("../pack/export_json");
+const export_toon_1 = require("../pack/export_toon");
+const export_xml_1 = require("../pack/export_xml");
+const EDGE_KEYS = new Set(["parent", "epic", "relates", "blocked_by", "blocks", "prev", "next"]);
+const FORMAT_KEYS = new Set(["md", "json", "toon", "xml"]);
+function normalizeWorkspace(value) {
+    if (!value || value === "all") {
+        return undefined;
+    }
+    return value;
+}
+function normalizeEdges(edges) {
+    const normalized = edges.map((edge) => edge.toLowerCase().replace(/-/g, "_"));
+    const invalid = normalized.filter((edge) => !EDGE_KEYS.has(edge));
+    if (invalid.length > 0) {
+        throw new errors_1.UsageError(`invalid edge name(s): ${invalid.join(", ")}`);
+    }
+    return Array.from(new Set(normalized));
+}
+function normalizeFormat(format) {
+    if (!format) {
+        return "md";
+    }
+    const normalized = format.toLowerCase();
+    if (!FORMAT_KEYS.has(normalized)) {
+        throw new errors_1.UsageError(`invalid format: ${format}`);
+    }
+    return normalized;
+}
+function runPackCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const ws = normalizeWorkspace(options.ws);
+    if (ws && !config.workspaces[ws]) {
+        throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
+    }
+    const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
+        root: options.root,
+        config,
+        useCache: !options.noCache,
+        allowReindex: !options.noReindex,
+    });
+    if (stale && !rebuilt && !options.noCache) {
+        console.error("warning: index is stale; run mdkg index to refresh");
+    }
+    const resolved = (0, qid_1.resolveQid)(index, options.id, ws);
+    if (resolved.status !== "ok") {
+        throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("id", options.id, resolved, ws));
+    }
+    const depth = options.depth ?? config.pack.default_depth;
+    if (!Number.isInteger(depth) || depth < 0) {
+        throw new errors_1.UsageError("--depth must be a non-negative integer");
+    }
+    const extraEdges = options.edges ? normalizeEdges(options.edges) : [];
+    const edges = normalizeEdges([...config.pack.default_edges, ...extraEdges]);
+    const buildResult = (0, pack_1.buildPack)({
+        root: options.root,
+        index,
+        rootQid: resolved.qid,
+        depth,
+        edges,
+        verbose: Boolean(options.verbose),
+        maxNodes: config.pack.limits.max_nodes,
+        verboseCoreListPath: path_1.default.resolve(options.root, config.pack.verbose_core_list_path),
+        wsHint: ws,
+    });
+    for (const warning of buildResult.warnings) {
+        console.error(`warning: ${warning}`);
+    }
+    const format = normalizeFormat(options.format);
+    let output = "";
+    if (format === "md") {
+        output = (0, export_md_1.exportMarkdown)(buildResult.pack, config.pack.limits.max_bytes).content;
+    }
+    else if (format === "json") {
+        output = (0, export_json_1.exportJson)(buildResult.pack);
+    }
+    else if (format === "toon") {
+        output = (0, export_toon_1.exportToon)(buildResult.pack);
+    }
+    else if (format === "xml") {
+        output = (0, export_xml_1.exportXml)(buildResult.pack);
+    }
+    const rootId = resolved.qid.split(":")[1] ?? resolved.qid;
+    const outPath = options.out
+        ? path_1.default.resolve(options.root, options.out)
+        : (0, output_1.buildDefaultPackPath)(options.root, rootId, format, Boolean(options.verbose), new Date());
+    fs_1.default.mkdirSync(path_1.default.dirname(outPath), { recursive: true });
+    fs_1.default.writeFileSync(outPath, output, "utf8");
+    console.log(`pack written: ${outPath}`);
+}

package/dist/commands/search.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSearchCommand = runSearchCommand;
+const config_1 = require("../core/config");
+const index_cache_1 = require("../graph/index_cache");
+const filter_1 = require("../util/filter");
+const errors_1 = require("../util/errors");
+const sort_1 = require("../util/sort");
+const node_card_1 = require("./node_card");
+function normalizeWorkspace(value) {
+    if (!value || value === "all") {
+        return undefined;
+    }
+    return value;
+}
+function buildSearchText(node) {
+    const tokens = [
+        node.id,
+        node.qid,
+        node.title,
+        node.path,
+        ...node.tags,
+        ...node.owners,
+        ...node.links,
+        ...node.artifacts,
+        ...node.refs,
+        ...node.aliases,
+    ];
+    return tokens.join(" ").toLowerCase();
+}
+function matchesQuery(node, terms) {
+    const text = buildSearchText(node);
+    for (const term of terms) {
+        if (!text.includes(term)) {
+            return false;
+        }
+    }
+    return true;
+}
+function runSearchCommand(options) {
+    const query = options.query.trim();
+    if (!query) {
+        throw new errors_1.UsageError("search query cannot be empty");
+    }
+    const config = (0, config_1.loadConfig)(options.root);
+    const ws = normalizeWorkspace(options.ws);
+    if (ws && !config.workspaces[ws]) {
+        throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
+    }
+    const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
+        root: options.root,
+        config,
+        useCache: !options.noCache,
+        allowReindex: !options.noReindex,
+    });
+    if (stale && !rebuilt && !options.noCache) {
+        console.error("warning: index is stale; run mdkg index to refresh");
+    }
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const filtered = (0, filter_1.filterNodes)(Object.values(index.nodes), {
+        ws,
+        type: options.type,
+        status: options.status,
+    });
+    const matches = filtered.filter((node) => matchesQuery(node, terms));
+    const sorted = (0, sort_1.sortNodesByQid)(matches);
+    for (const node of sorted) {
+        console.log((0, node_card_1.formatNodeCard)(node));
+    }
+}

package/dist/commands/show.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runShowCommand = runShowCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../core/config");
+const index_cache_1 = require("../graph/index_cache");
+const frontmatter_1 = require("../graph/frontmatter");
+const errors_1 = require("../util/errors");
+const qid_1 = require("../util/qid");
+const node_card_1 = require("./node_card");
+function normalizeWorkspace(value) {
+    if (!value || value === "all") {
+        return undefined;
+    }
+    return value;
+}
+function maybeLine(label, values) {
+    if (values.length === 0) {
+        return undefined;
+    }
+    return `${label}: ${values.join(", ")}`;
+}
+function runShowCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const ws = normalizeWorkspace(options.ws);
+    if (ws && !config.workspaces[ws]) {
+        throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
+    }
+    const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
+        root: options.root,
+        config,
+        useCache: !options.noCache,
+        allowReindex: !options.noReindex,
+    });
+    if (stale && !rebuilt && !options.noCache) {
+        console.error("warning: index is stale; run mdkg index to refresh");
+    }
+    const resolved = (0, qid_1.resolveQid)(index, options.id, ws);
+    if (resolved.status !== "ok") {
+        throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("id", options.id, resolved, ws));
+    }
+    const node = index.nodes[resolved.qid];
+    const lines = [];
+    lines.push((0, node_card_1.formatNodeCard)(node));
+    const metaLines = [
+        maybeLine("tags", node.tags),
+        maybeLine("owners", node.owners),
+        maybeLine("links", node.links),
+        maybeLine("artifacts", node.artifacts),
+        maybeLine("refs", node.refs),
+        maybeLine("aliases", node.aliases),
+    ].filter((line) => Boolean(line));
+    lines.push(...metaLines);
+    if (node.edges.epic) {
+        lines.push(`epic: ${node.edges.epic}`);
+    }
+    if (node.edges.parent) {
+        lines.push(`parent: ${node.edges.parent}`);
+    }
+    if (node.edges.prev) {
+        lines.push(`prev: ${node.edges.prev}`);
+    }
+    if (node.edges.next) {
+        lines.push(`next: ${node.edges.next}`);
+    }
+    const relatesLine = maybeLine("relates", node.edges.relates);
+    if (relatesLine) {
+        lines.push(relatesLine);
+    }
+    const blockedByLine = maybeLine("blocked_by", node.edges.blocked_by);
+    if (blockedByLine) {
+        lines.push(blockedByLine);
+    }
+    const blocksLine = maybeLine("blocks", node.edges.blocks);
+    if (blocksLine) {
+        lines.push(blocksLine);
+    }
+    if (options.includeBody) {
+        const filePath = path_1.default.resolve(options.root, node.path);
+        if (!fs_1.default.existsSync(filePath)) {
+            throw new errors_1.NotFoundError(`file not found for ${node.qid}: ${node.path}`);
+        }
+        const content = fs_1.default.readFileSync(filePath, "utf8");
+        const body = (0, frontmatter_1.parseFrontmatter)(content, filePath).body.trimEnd();
+        if (body.length > 0) {
+            lines.push("");
+            lines.push(body);
+        }
+    }
+    console.log(lines.join("\n"));
+}