mdkg 0.0.1 → 0.0.2

package/dist/pack/export_json.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportJson = exportJson;
+function buildFrontmatter(node) {
+    const frontmatter = {};
+    if (node.links.length > 0) {
+        frontmatter.links = node.links;
+    }
+    if (node.artifacts.length > 0) {
+        frontmatter.artifacts = node.artifacts;
+    }
+    if (node.refs.length > 0) {
+        frontmatter.refs = node.refs;
+    }
+    if (node.aliases.length > 0) {
+        frontmatter.aliases = node.aliases;
+    }
+    return frontmatter;
+}
+function exportJson(pack) {
+    const nodes = pack.nodes.map((node) => ({
+        qid: node.qid,
+        id: node.id,
+        workspace: node.workspace,
+        type: node.type,
+        title: node.title,
+        status: node.status,
+        priority: node.priority,
+        path: node.path,
+        frontmatter: buildFrontmatter(node),
+        body: node.body,
+    }));
+    const payload = {
+        meta: pack.meta,
+        nodes,
+    };
+    return JSON.stringify(payload, null, 2);
+}

package/dist/pack/export_md.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportMarkdown = exportMarkdown;
+function formatList(label, values) {
+    if (values.length === 0) {
+        return `${label}: []`;
+    }
+    return `${label}: ${values.join(", ")}`;
+}
+function renderHeader(meta, nodes) {
+    const lines = [];
+    lines.push("# mdkg pack");
+    lines.push(`root: ${meta.root}`);
+    lines.push(`depth: ${meta.depth}`);
+    lines.push(`verbose: ${meta.verbose}`);
+    lines.push(`nodes: ${nodes.length}`);
+    lines.push(`truncated: max_nodes=${meta.truncated.max_nodes} max_bytes=${meta.truncated.max_bytes}`);
+    if (meta.truncated.dropped.length > 0) {
+        lines.push(`dropped: ${meta.truncated.dropped.join(", ")}`);
+    }
+    lines.push(`generated_at: ${meta.generated_at}`);
+    lines.push("");
+    lines.push("included_nodes:");
+    for (const node of nodes) {
+        lines.push(`- ${node.qid}`);
+    }
+    return lines;
+}
+function renderNode(node) {
+    const lines = [];
+    lines.push(`## ${node.qid}`);
+    lines.push(`qid: ${node.qid}`);
+    lines.push(`type: ${node.type}`);
+    lines.push(`title: ${node.title}`);
+    if (node.status) {
+        lines.push(`status: ${node.status}`);
+    }
+    if (node.priority !== undefined) {
+        lines.push(`priority: ${node.priority}`);
+    }
+    lines.push(`path: ${node.path}`);
+    lines.push(formatList("links", node.links));
+    lines.push(formatList("artifacts", node.artifacts));
+    if (node.refs.length > 0) {
+        lines.push(formatList("refs", node.refs));
+    }
+    if (node.body.trim().length > 0) {
+        lines.push("");
+        lines.push(node.body);
+    }
+    return lines;
+}
+function cloneTruncation(truncation) {
+    return {
+        max_nodes: truncation.max_nodes,
+        max_bytes: truncation.max_bytes,
+        dropped: [...truncation.dropped],
+    };
+}
+function buildMeta(meta, nodes) {
+    return {
+        ...meta,
+        node_count: nodes.length,
+        truncated: cloneTruncation(meta.truncated),
+    };
+}
+function renderMarkdown(meta, nodes) {
+    const lines = [];
+    lines.push(...renderHeader(meta, nodes));
+    for (const node of nodes) {
+        lines.push("");
+        lines.push("---");
+        lines.push("");
+        lines.push(...renderNode(node));
+    }
+    return lines.join("\n");
+}
+function exportMarkdown(pack, maxBytes) {
+    let nodes = pack.nodes;
+    let meta = buildMeta(pack.meta, nodes);
+    let content = renderMarkdown(meta, nodes);
+    if (maxBytes !== undefined && maxBytes > 0 && Buffer.byteLength(content) > maxBytes) {
+        meta.truncated.max_bytes = true;
+        while (nodes.length > 1 && Buffer.byteLength(content) > maxBytes) {
+            const dropped = nodes[nodes.length - 1];
+            nodes = nodes.slice(0, -1);
+            meta.truncated.dropped.push(dropped.qid);
+            meta = buildMeta(meta, nodes);
+            content = renderMarkdown(meta, nodes);
+        }
+    }
+    return { content, meta, nodes };
+}

package/dist/pack/export_toon.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportToon = exportToon;
+const export_json_1 = require("./export_json");
+function exportToon(pack) {
+    return (0, export_json_1.exportJson)(pack);
+}

package/dist/pack/export_xml.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportXml = exportXml;
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function listItems(tag, itemTag, items, indent) {
+    if (items.length === 0) {
+        return [];
+    }
+    const lines = [];
+    lines.push(`${indent}<${tag}>`);
+    for (const item of items) {
+        lines.push(`${indent}  <${itemTag}>${escapeXml(item)}</${itemTag}>`);
+    }
+    lines.push(`${indent}</${tag}>`);
+    return lines;
+}
+function exportXml(pack) {
+    const lines = [];
+    lines.push("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+    lines.push("<pack>");
+    lines.push("  <meta>");
+    lines.push(`    <root>${escapeXml(pack.meta.root)}</root>`);
+    lines.push(`    <depth>${pack.meta.depth}</depth>`);
+    lines.push(`    <verbose>${pack.meta.verbose}</verbose>`);
+    lines.push(`    <generated_at>${escapeXml(pack.meta.generated_at)}</generated_at>`);
+    lines.push(`    <node_count>${pack.meta.node_count}</node_count>`);
+    lines.push("    <truncated>");
+    lines.push(`      <max_nodes>${pack.meta.truncated.max_nodes}</max_nodes>`);
+    lines.push(`      <max_bytes>${pack.meta.truncated.max_bytes}</max_bytes>`);
+    if (pack.meta.truncated.dropped.length > 0) {
+        lines.push("      <dropped>");
+        for (const qid of pack.meta.truncated.dropped) {
+            lines.push(`        <qid>${escapeXml(qid)}</qid>`);
+        }
+        lines.push("      </dropped>");
+    }
+    lines.push("    </truncated>");
+    lines.push("  </meta>");
+    lines.push("  <nodes>");
+    for (const node of pack.nodes) {
+        lines.push("    <node>");
+        lines.push(`      <qid>${escapeXml(node.qid)}</qid>`);
+        lines.push(`      <id>${escapeXml(node.id)}</id>`);
+        lines.push(`      <workspace>${escapeXml(node.workspace)}</workspace>`);
+        lines.push(`      <type>${escapeXml(node.type)}</type>`);
+        lines.push(`      <title>${escapeXml(node.title)}</title>`);
+        if (node.status) {
+            lines.push(`      <status>${escapeXml(node.status)}</status>`);
+        }
+        if (node.priority !== undefined) {
+            lines.push(`      <priority>${node.priority}</priority>`);
+        }
+        lines.push(`      <path>${escapeXml(node.path)}</path>`);
+        lines.push("      <frontmatter>");
+        lines.push(...listItems("links", "link", node.links, "        "));
+        lines.push(...listItems("artifacts", "artifact", node.artifacts, "        "));
+        lines.push(...listItems("refs", "ref", node.refs, "        "));
+        lines.push(...listItems("aliases", "alias", node.aliases, "        "));
+        lines.push("      </frontmatter>");
+        lines.push(`      <body>${escapeXml(node.body)}</body>`);
+        lines.push("    </node>");
+    }
+    lines.push("  </nodes>");
+    lines.push("</pack>");
+    return lines.join("\n");
+}

package/dist/pack/order.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderPackNodes = orderPackNodes;
+const ARCH_TYPES = ["edd", "dec", "rule"];
+const FALLBACK_TYPES = [
+    "edd",
+    "dec",
+    "rule",
+    "prd",
+    "prop",
+    "epic",
+    "feat",
+    "task",
+    "bug",
+    "checkpoint",
+];
+const WORK_TYPES = ["epic", "feat", "task", "bug", "checkpoint"];
+function idNumber(id) {
+    const match = id.match(/-(\d+)$/);
+    if (!match) {
+        return Number.POSITIVE_INFINITY;
+    }
+    const parsed = Number.parseInt(match[1], 10);
+    return Number.isNaN(parsed) ? Number.POSITIVE_INFINITY : parsed;
+}
+function typePriority(type, order) {
+    const idx = order.indexOf(type);
+    if (idx === -1) {
+        return order.length + 1;
+    }
+    return idx;
+}
+function rootRelationPriority(rootEdges, qid) {
+    if (rootEdges.blocked_by.includes(qid)) {
+        return 0;
+    }
+    if (rootEdges.blocks.includes(qid)) {
+        return 1;
+    }
+    if (rootEdges.prev === qid) {
+        return 2;
+    }
+    if (rootEdges.next === qid) {
+        return 3;
+    }
+    if (rootEdges.relates.includes(qid)) {
+        return 4;
+    }
+    return 5;
+}
+function immediateContextPriority(rootEdges, qid, nodeType) {
+    if (rootEdges.parent === qid) {
+        return 0;
+    }
+    if (rootEdges.epic === qid) {
+        return 1;
+    }
+    if (rootEdges.relates.includes(qid) && nodeType === "checkpoint") {
+        return 2;
+    }
+    if (rootEdges.blocked_by.includes(qid) || rootEdges.blocks.includes(qid)) {
+        return 3;
+    }
+    return undefined;
+}
+function buildOrderKey(index, rootQid, qid, depths) {
+    const node = index.nodes[qid];
+    const root = index.nodes[rootQid];
+    const depth = depths.get(qid);
+    const rootIsTask = root.type === "task" || root.type === "bug";
+    if (qid === rootQid) {
+        return {
+            group: 0,
+            subgroup: 0,
+            type_priority: 0,
+            id_number: idNumber(node.id),
+            title: node.title.toLowerCase(),
+            qid,
+        };
+    }
+    if (rootIsTask) {
+        const immediatePriority = depth === 1 ? immediateContextPriority(root.edges, qid, node.type) : undefined;
+        if (immediatePriority !== undefined) {
+            return {
+                group: 1,
+                subgroup: immediatePriority,
+                type_priority: 0,
+                id_number: idNumber(node.id),
+                title: node.title.toLowerCase(),
+                qid,
+            };
+        }
+        if (ARCH_TYPES.includes(node.type)) {
+            return {
+                group: 2,
+                subgroup: 0,
+                type_priority: typePriority(node.type, ARCH_TYPES),
+                id_number: idNumber(node.id),
+                title: node.title.toLowerCase(),
+                qid,
+            };
+        }
+        if (node.type === "prd") {
+            return {
+                group: 3,
+                subgroup: 0,
+                type_priority: 0,
+                id_number: idNumber(node.id),
+                title: node.title.toLowerCase(),
+                qid,
+            };
+        }
+        if (node.type === "prop") {
+            return {
+                group: 4,
+                subgroup: 0,
+                type_priority: 0,
+                id_number: idNumber(node.id),
+                title: node.title.toLowerCase(),
+                qid,
+            };
+        }
+        return {
+            group: 5,
+            subgroup: rootRelationPriority(root.edges, qid),
+            type_priority: typePriority(node.type, WORK_TYPES),
+            id_number: idNumber(node.id),
+            title: node.title.toLowerCase(),
+            qid,
+        };
+    }
+    return {
+        group: 1,
+        subgroup: typePriority(node.type, FALLBACK_TYPES),
+        type_priority: 0,
+        id_number: idNumber(node.id),
+        title: node.title.toLowerCase(),
+        qid,
+    };
+}
+function orderPackNodes(index, rootQid, qids, depths) {
+    return [...qids].sort((a, b) => {
+        const keyA = buildOrderKey(index, rootQid, a, depths);
+        const keyB = buildOrderKey(index, rootQid, b, depths);
+        if (keyA.group !== keyB.group) {
+            return keyA.group - keyB.group;
+        }
+        if (keyA.subgroup !== keyB.subgroup) {
+            return keyA.subgroup - keyB.subgroup;
+        }
+        if (keyA.type_priority !== keyB.type_priority) {
+            return keyA.type_priority - keyB.type_priority;
+        }
+        if (keyA.id_number !== keyB.id_number) {
+            return keyA.id_number - keyB.id_number;
+        }
+        if (keyA.title !== keyB.title) {
+            return keyA.title.localeCompare(keyB.title);
+        }
+        return keyA.qid.localeCompare(keyB.qid);
+    });
+}

package/dist/pack/pack.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPack = buildPack;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const frontmatter_1 = require("../graph/frontmatter");
+const qid_1 = require("../util/qid");
+const order_1 = require("./order");
+const verbose_core_1 = require("./verbose_core");
+const EDGE_KEYS = ["parent", "epic", "relates", "blocked_by", "blocks", "prev", "next"];
+function normalizeEdgeList(edges) {
+    const seen = new Set();
+    const result = [];
+    for (const edge of edges) {
+        const normalized = edge.trim().toLowerCase().replace(/-/g, "_");
+        if (!EDGE_KEYS.includes(normalized)) {
+            continue;
+        }
+        if (!seen.has(normalized)) {
+            seen.add(normalized);
+            result.push(normalized);
+        }
+    }
+    return result;
+}
+function getNeighbors(index, qid, edges) {
+    const node = index.nodes[qid];
+    if (!node) {
+        return [];
+    }
+    const neighbors = [];
+    for (const edge of edges) {
+        switch (edge) {
+            case "parent":
+                if (node.edges.parent) {
+                    neighbors.push(node.edges.parent);
+                }
+                break;
+            case "epic":
+                if (node.edges.epic) {
+                    neighbors.push(node.edges.epic);
+                }
+                break;
+            case "prev":
+                if (node.edges.prev) {
+                    neighbors.push(node.edges.prev);
+                }
+                break;
+            case "next":
+                if (node.edges.next) {
+                    neighbors.push(node.edges.next);
+                }
+                break;
+            case "relates":
+                neighbors.push(...node.edges.relates);
+                break;
+            case "blocked_by":
+                neighbors.push(...node.edges.blocked_by);
+                break;
+            case "blocks":
+                neighbors.push(...node.edges.blocks);
+                break;
+            default:
+                break;
+        }
+    }
+    return neighbors;
+}
+function collectNodes(index, rootQid, depth, edges) {
+    const selectedEdges = normalizeEdgeList(edges);
+    const visited = new Set();
+    const depths = new Map();
+    const queue = [];
+    queue.push({ qid: rootQid, depth: 0 });
+    visited.add(rootQid);
+    depths.set(rootQid, 0);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            break;
+        }
+        if (current.depth >= depth) {
+            continue;
+        }
+        const neighbors = getNeighbors(index, current.qid, selectedEdges);
+        for (const neighbor of neighbors) {
+            if (!index.nodes[neighbor]) {
+                continue;
+            }
+            if (visited.has(neighbor)) {
+                continue;
+            }
+            visited.add(neighbor);
+            depths.set(neighbor, current.depth + 1);
+            queue.push({ qid: neighbor, depth: current.depth + 1 });
+        }
+    }
+    return { qids: visited, depths };
+}
+function buildPackNode(root, index, qid) {
+    const node = index.nodes[qid];
+    if (!node) {
+        throw new Error(`node not found: ${qid}`);
+    }
+    const filePath = path_1.default.resolve(root, node.path);
+    if (!fs_1.default.existsSync(filePath)) {
+        throw new Error(`file not found for ${qid}: ${node.path}`);
+    }
+    const content = fs_1.default.readFileSync(filePath, "utf8");
+    const body = (0, frontmatter_1.parseFrontmatter)(content, filePath).body.trimEnd();
+    return {
+        qid: node.qid,
+        id: node.id,
+        workspace: node.ws,
+        type: node.type,
+        title: node.title,
+        status: node.status,
+        priority: node.priority,
+        path: node.path,
+        links: node.links,
+        artifacts: node.artifacts,
+        refs: node.refs,
+        aliases: node.aliases,
+        body,
+    };
+}
+function mergeWarnings(warnings, message) {
+    warnings.push(message);
+}
+function applyMaxNodes(orderedQids, maxNodes, truncation) {
+    if (maxNodes <= 0 || orderedQids.length <= maxNodes) {
+        return { included: orderedQids, dropped: [] };
+    }
+    const included = orderedQids.slice(0, maxNodes);
+    const dropped = orderedQids.slice(maxNodes);
+    truncation.max_nodes = true;
+    truncation.dropped.push(...dropped);
+    return { included, dropped };
+}
+function buildPack(options) {
+    const warnings = [];
+    const { qids, depths } = collectNodes(options.index, options.rootQid, options.depth, options.edges);
+    if (options.verbose) {
+        const coreIds = (0, verbose_core_1.readVerboseCoreList)(options.verboseCoreListPath);
+        for (const id of coreIds) {
+            const resolved = (0, qid_1.resolveQid)(options.index, id, options.wsHint);
+            if (resolved.status === "ok") {
+                qids.add(resolved.qid);
+            }
+            else if (resolved.status === "ambiguous") {
+                mergeWarnings(warnings, `verbose core id ambiguous: ${id}`);
+            }
+            else {
+                mergeWarnings(warnings, `verbose core id missing: ${id}`);
+            }
+        }
+    }
+    const ordered = (0, order_1.orderPackNodes)(options.index, options.rootQid, Array.from(qids), depths);
+    const truncation = {
+        max_nodes: false,
+        max_bytes: false,
+        dropped: [],
+    };
+    const { included } = applyMaxNodes(ordered, options.maxNodes, truncation);
+    const nodes = included.map((qid) => buildPackNode(options.root, options.index, qid));
+    const pack = {
+        meta: {
+            root: options.rootQid,
+            depth: options.depth,
+            verbose: options.verbose,
+            generated_at: new Date().toISOString(),
+            node_count: nodes.length,
+            truncated: truncation,
+        },
+        nodes,
+    };
+    return { pack, warnings };
+}

package/dist/pack/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/pack/verbose_core.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readVerboseCoreList = readVerboseCoreList;
+const fs_1 = __importDefault(require("fs"));
+function readVerboseCoreList(listPath) {
+    if (!fs_1.default.existsSync(listPath)) {
+        throw new Error(`verbose core list not found: ${listPath}`);
+    }
+    const raw = fs_1.default.readFileSync(listPath, "utf8");
+    const lines = raw.split(/\r?\n/);
+    const ids = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        ids.push(trimmed.toLowerCase());
+    }
+    return ids;
+}

package/dist/templates/loader.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTemplate = loadTemplate;
+exports.renderTemplate = renderTemplate;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const frontmatter_1 = require("../graph/frontmatter");
+const errors_1 = require("../util/errors");
+function templateNameForType(type) {
+    const normalized = type.toLowerCase();
+    if (normalized === "checkpoint") {
+        return "chk";
+    }
+    return normalized;
+}
+function loadTemplate(root, config, type, templateSet) {
+    const setName = (templateSet ?? config.templates.default_set).toLowerCase();
+    const templateName = templateNameForType(type);
+    const templatePath = path_1.default.resolve(root, config.templates.root_path, setName, `${templateName}.md`);
+    if (!fs_1.default.existsSync(templatePath)) {
+        throw new errors_1.NotFoundError(`template not found: ${setName}/${templateName}.md`);
+    }
+    const content = fs_1.default.readFileSync(templatePath, "utf8");
+    const { frontmatter, body } = (0, frontmatter_1.parseFrontmatter)(content, templatePath);
+    return { templatePath, frontmatter, body };
+}
+function isTokenPlaceholder(value) {
+    return typeof value === "string" && /^\{\{[a-z0-9_]+\}\}$/.test(value);
+}
+function tokenKey(value) {
+    return value.slice(2, -2);
+}
+function renderTokenValue(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return String(value);
+    }
+    return value;
+}
+function renderTemplate(template, context) {
+    const allowedKeys = new Set(Object.keys(template.frontmatter));
+    const rendered = {};
+    for (const [key, value] of Object.entries(template.frontmatter)) {
+        if (isTokenPlaceholder(value)) {
+            const replacement = renderTokenValue(context[tokenKey(value)]);
+            if (replacement !== undefined) {
+                rendered[key] = replacement;
+            }
+            continue;
+        }
+        rendered[key] = value;
+    }
+    for (const [key, value] of Object.entries(context)) {
+        if (!allowedKeys.has(key)) {
+            continue;
+        }
+        const replacement = renderTokenValue(value);
+        if (replacement !== undefined) {
+            rendered[key] = replacement;
+        }
+    }
+    const lines = [];
+    lines.push("---");
+    lines.push(...(0, frontmatter_1.formatFrontmatter)(rendered));
+    lines.push("---");
+    lines.push(template.body.trimStart());
+    if (!lines[lines.length - 1]?.endsWith("\n")) {
+        lines.push("");
+    }
+    return lines.join("\n");
+}