mdkg 0.0.3 → 0.0.4

package/dist/commands/new.js

@@ -14,10 +14,11 @@ 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 id_1 = require("../util/id");
+const event_support_1 = require("./event_support");
 const DEC_ID_RE = /^dec-[0-9]+$/;
 const DEC_STATUS = new Set(["proposed", "accepted", "rejected", "superseded"]);
+const SKILL_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const CORE_TYPES = new Set(["rule"]);
 const DESIGN_TYPES = new Set(["prd", "edd", "dec", "prop"]);
 function parseCsvList(raw) {
@@ -31,14 +32,14 @@ function parseCsvList(raw) {
 }
 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}`);
+    if (!(0, id_1.isCanonicalId)(normalized)) {
+        throw new errors_1.UsageError(`${key} entries must match <prefix>-<number> or reserved id: ${value}`);
     }
     return normalized;
 }
 function normalizeIdRef(value, key) {
     const normalized = value.toLowerCase();
-    if (!ID_REF_RE.test(normalized)) {
+    if (!(0, id_1.isCanonicalIdRef)(normalized)) {
         throw new errors_1.UsageError(`${key} entries must match <id> or <ws>:<id>: ${value}`);
     }
     return normalized;
@@ -55,6 +56,15 @@ function normalizeIdList(raw, key) {
 function normalizeIdRefList(raw, key) {
     return parseCsvList(raw).map((value) => normalizeIdRef(value, key));
 }
+function normalizeSkillList(raw) {
+    return parseCsvList(raw).map((value) => {
+        const normalized = value.toLowerCase();
+        if (!SKILL_SLUG_RE.test(normalized)) {
+            throw new errors_1.UsageError(`--skills entries must be kebab-case: ${value}`);
+        }
+        return normalized;
+    });
+}
 function normalizeWorkspace(value) {
     if (!value) {
         return "root";
@@ -206,8 +216,12 @@ function runNewCommand(options) {
     const tags = normalizeLowercaseList(options.tags);
     const owners = normalizeLowercaseList(options.owners);
     const cases = normalizeLowercaseList(options.cases);
+    const skills = normalizeSkillList(options.skills);
     const links = normalizeList(options.links);
     const artifacts = normalizeList(options.artifacts);
+    if (skills.length > 0 && !node_1.WORK_TYPES.has(type)) {
+        throw new errors_1.UsageError("--skills is only valid for work items");
+    }
     if (type === "dec" && options.supersedes) {
         const supersedes = options.supersedes.toLowerCase();
         if (!DEC_ID_RE.test(supersedes)) {
@@ -263,6 +277,7 @@ function runNewCommand(options) {
         artifacts: artifacts.length > 0 ? artifacts : undefined,
         refs: refs.length > 0 ? refs : undefined,
         aliases: aliases.length > 0 ? aliases : undefined,
+        skills: skills.length > 0 ? skills : undefined,
         cases: cases.length > 0 ? cases : undefined,
         supersedes: options.supersedes ? options.supersedes.toLowerCase() : undefined,
         created: today,
@@ -275,5 +290,15 @@ function runNewCommand(options) {
         const outputPath = path_1.default.resolve(options.root, config.index.global_index_path);
         (0, index_cache_1.writeIndex)(outputPath, updatedIndex);
     }
+    (0, event_support_1.appendAutomaticEvent)({
+        root: options.root,
+        ws,
+        kind: "NODE_CREATED",
+        status: "ok",
+        refs: [id],
+        notes: `node created via mdkg new`,
+        runId: options.runId,
+        now: options.now,
+    });
     console.log(`node created: ${ws}:${id} (${path_1.default.relative(options.root, filePath)})`);
 }

package/dist/commands/pack.js

@@ -8,6 +8,8 @@ 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 skills_index_cache_1 = require("../graph/skills_index_cache");
 const node_1 = require("../graph/node");
 const budget_1 = require("../pack/budget");
 const export_json_1 = require("../pack/export_json");
@@ -24,6 +26,7 @@ const output_1 = require("../util/output");
 const qid_1 = require("../util/qid");
 const EDGE_KEYS = new Set(["parent", "epic", "relates", "blocked_by", "blocks", "prev", "next"]);
 const FORMAT_KEYS = new Set(["md", "json", "toon", "xml"]);
+const SKILL_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function normalizeWorkspace(value) {
     if (!value || value === "all") {
         return undefined;
@@ -48,6 +51,158 @@ function normalizeFormat(format) {
     }
     return normalized;
 }
+function normalizeSkillSlug(slug) {
+    const normalized = slug.toLowerCase().trim();
+    if (!SKILL_SLUG_RE.test(normalized)) {
+        throw new errors_1.UsageError(`invalid skill slug: ${slug}`);
+    }
+    return normalized;
+}
+function resolveSkillsPolicy(raw) {
+    if (!raw) {
+        return { mode: "auto" };
+    }
+    const normalized = raw.toLowerCase().trim();
+    if (!normalized || normalized === "auto") {
+        return { mode: "auto" };
+    }
+    if (normalized === "none") {
+        return { mode: "none" };
+    }
+    const slugs = normalized
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .map((value) => normalizeSkillSlug(value));
+    if (slugs.length === 0) {
+        return { mode: "none" };
+    }
+    return { mode: "list", slugs: Array.from(new Set(slugs)) };
+}
+function resolveSkillsDepth(raw) {
+    if (!raw) {
+        return "meta";
+    }
+    const normalized = raw.toLowerCase().trim();
+    if (normalized === "meta" || normalized === "full") {
+        return normalized;
+    }
+    throw new errors_1.UsageError("--skills-depth must be meta or full");
+}
+function renderSkillMetaBody(skill) {
+    const lines = [];
+    lines.push(`description: ${skill.description}`);
+    if (skill.tags.length > 0) {
+        lines.push(`tags: ${skill.tags.join(", ")}`);
+    }
+    if (skill.version) {
+        lines.push(`version: ${skill.version}`);
+    }
+    if (skill.authors.length > 0) {
+        lines.push(`authors: ${skill.authors.join(", ")}`);
+    }
+    if (skill.links.length > 0) {
+        lines.push(`links: ${skill.links.join(", ")}`);
+    }
+    lines.push(`has_scripts: ${skill.has_scripts ? "true" : "false"}`);
+    lines.push(`has_references: ${skill.has_references ? "true" : "false"}`);
+    for (const [key, value] of Object.entries(skill.ochatr).sort(([a], [b]) => a.localeCompare(b))) {
+        if (Array.isArray(value)) {
+            lines.push(`${key}: ${value.join(", ")}`);
+        }
+        else if (typeof value === "boolean") {
+            lines.push(`${key}: ${value ? "true" : "false"}`);
+        }
+        else {
+            lines.push(`${key}: ${value}`);
+        }
+    }
+    return lines.join("\n").trimEnd();
+}
+function loadSkillFullBody(root, skill) {
+    const skillPath = path_1.default.resolve(root, skill.path);
+    if (!fs_1.default.existsSync(skillPath)) {
+        return renderSkillMetaBody(skill);
+    }
+    const content = fs_1.default.readFileSync(skillPath, "utf8");
+    return (0, frontmatter_1.parseFrontmatter)(content, skillPath).body.trimEnd();
+}
+function uniqueSkillOrder(slugs) {
+    const seen = new Set();
+    const ordered = [];
+    for (const slug of slugs) {
+        if (seen.has(slug)) {
+            continue;
+        }
+        seen.add(slug);
+        ordered.push(slug);
+    }
+    return ordered;
+}
+function collectReferencedSkills(indexQids, indexNodes) {
+    const slugs = [];
+    for (const qid of indexQids) {
+        const node = indexNodes[qid];
+        if (!node) {
+            continue;
+        }
+        if (node.type === "skill") {
+            continue;
+        }
+        slugs.push(...node.skills);
+    }
+    return uniqueSkillOrder(slugs);
+}
+function appendSkillsToPack(pack, skillEntries, depth, root) {
+    const existing = new Set(pack.nodes.map((node) => node.qid));
+    const newNodes = skillEntries
+        .filter((skill) => !existing.has(skill.qid))
+        .map((skill) => ({
+        qid: skill.qid,
+        id: skill.id,
+        workspace: skill.ws,
+        type: "skill",
+        title: skill.name,
+        status: undefined,
+        priority: undefined,
+        path: skill.path,
+        links: skill.links,
+        artifacts: [],
+        refs: [],
+        aliases: [skill.slug, ...skill.tags],
+        body: depth === "full" ? loadSkillFullBody(root, skill) : renderSkillMetaBody(skill),
+    }));
+    if (newNodes.length === 0) {
+        return pack;
+    }
+    const mergedNodes = [...pack.nodes, ...newNodes];
+    return {
+        meta: {
+            ...pack.meta,
+            node_count: mergedNodes.length,
+        },
+        nodes: mergedNodes,
+    };
+}
+function applyNodeCountLimit(pack, maxNodes) {
+    if (maxNodes <= 0 || pack.nodes.length <= maxNodes) {
+        return pack;
+    }
+    const included = pack.nodes.slice(0, maxNodes);
+    const dropped = pack.nodes.slice(maxNodes).map((node) => node.qid);
+    return {
+        meta: {
+            ...pack.meta,
+            node_count: included.length,
+            truncated: {
+                ...pack.meta.truncated,
+                max_nodes: true,
+                dropped: [...pack.meta.truncated.dropped, ...dropped],
+            },
+        },
+        nodes: included,
+    };
+}
 function writeJsonFile(outPath, payload) {
     fs_1.default.mkdirSync(path_1.default.dirname(outPath), { recursive: true });
     fs_1.default.writeFileSync(outPath, JSON.stringify(payload, null, 2), "utf8");
@@ -76,6 +231,12 @@ function printDryRunSummary(pack, stats, format) {
     console.log(`body_mode: ${pack.meta.body_mode ?? "full"}`);
     console.log(`format: ${format}`);
     console.log(`nodes: ${pack.nodes.length}`);
+    if (pack.meta.latest_checkpoint_qid) {
+        console.log(`latest_checkpoint_qid: ${pack.meta.latest_checkpoint_qid}`);
+    }
+    if (pack.meta.latest_checkpoint_qid_hint) {
+        console.log(`latest_checkpoint_qid_hint: ${pack.meta.latest_checkpoint_qid_hint}`);
+    }
     if (pack.meta.truncated.dropped.length > 0) {
         console.log(`dropped: ${pack.meta.truncated.dropped.join(", ")}`);
     }
@@ -114,6 +275,8 @@ function runPackCommand(options) {
     }
     const extraEdges = options.edges ? normalizeEdges(options.edges) : [];
     const edges = normalizeEdges([...config.pack.default_edges, ...extraEdges]);
+    const skillsPolicy = resolveSkillsPolicy(options.skills);
+    const skillsDepth = resolveSkillsDepth(options.skillsDepth);
     let resolvedProfile;
     try {
         resolvedProfile = (0, profile_1.resolvePackProfile)({
@@ -128,7 +291,7 @@ function runPackCommand(options) {
         throw new errors_1.UsageError(message);
     }
     if (options.verbose && resolvedProfile.profile !== "standard") {
-        throw new errors_1.UsageError("--verbose is only supported with --pack-profile standard");
+        throw new errors_1.UsageError("--verbose is only supported with --profile standard");
     }
     const buildResult = (0, pack_1.buildPack)({
         root: options.root,
@@ -140,14 +303,43 @@ function runPackCommand(options) {
         maxNodes: config.pack.limits.max_nodes,
         verboseCoreListPath: path_1.default.resolve(options.root, config.pack.verbose_core_list_path),
         wsHint: ws,
+        includeLatestCheckpoint: true,
     });
     for (const warning of buildResult.warnings) {
         console.error(`warning: ${warning}`);
     }
+    let packWithSkills = buildResult.pack;
+    if (skillsPolicy.mode !== "none") {
+        const skillsLoad = (0, skills_index_cache_1.loadSkillsIndex)({
+            root: options.root,
+            config,
+            useCache: !options.noCache,
+            allowReindex: !options.noReindex,
+        });
+        if (skillsLoad.stale && !skillsLoad.rebuilt && !options.noCache) {
+            console.error("warning: skills index is stale; run mdkg index to refresh");
+        }
+        const indexQids = buildResult.pack.nodes.map((node) => node.qid);
+        const autoSlugs = collectReferencedSkills(indexQids, index.nodes);
+        const selectedSlugs = skillsPolicy.mode === "list"
+            ? skillsPolicy.slugs
+            : autoSlugs;
+        const selectedEntries = [];
+        for (const slug of selectedSlugs) {
+            const entry = skillsLoad.index.skills[slug];
+            if (!entry) {
+                console.error(`warning: requested skill missing: ${slug}`);
+                continue;
+            }
+            selectedEntries.push(entry);
+        }
+        packWithSkills = appendSkillsToPack(packWithSkills, selectedEntries, skillsDepth, options.root);
+        packWithSkills = applyNodeCountLimit(packWithSkills, config.pack.limits.max_nodes);
+    }
     const templateHeadingMap = resolvedProfile.bodyMode === "summary"
         ? (0, headings_1.loadTemplateHeadingMap)(options.root, config, Array.from(node_1.ALLOWED_TYPES))
         : {};
-    const shaped = (0, profile_1.shapePackBodies)(buildResult.pack, {
+    const shaped = (0, profile_1.shapePackBodies)(packWithSkills, {
         resolved: resolvedProfile,
         templateHeadingMap,
     });

package/dist/commands/query_output.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNodeSummaryJson = toNodeSummaryJson;
+exports.toNodeDetailJson = toNodeDetailJson;
+exports.toSkillSummaryJson = toSkillSummaryJson;
+exports.toSkillDetailJson = toSkillDetailJson;
+exports.writeJson = writeJson;
+exports.writeCount = writeCount;
+function toNodeSummaryJson(node) {
+    return {
+        id: node.id,
+        qid: node.qid,
+        ws: node.ws,
+        type: node.type,
+        title: node.title,
+        status: node.status,
+        priority: node.priority,
+        created: node.created,
+        updated: node.updated,
+        tags: [...node.tags],
+        owners: [...node.owners],
+        links: [...node.links],
+        artifacts: [...node.artifacts],
+        refs: [...node.refs],
+        aliases: [...node.aliases],
+        skills: [...node.skills],
+        path: node.path,
+        edges: {
+            epic: node.edges.epic,
+            parent: node.edges.parent,
+            prev: node.edges.prev,
+            next: node.edges.next,
+            relates: [...node.edges.relates],
+            blocked_by: [...node.edges.blocked_by],
+            blocks: [...node.edges.blocks],
+        },
+    };
+}
+function toNodeDetailJson(node, body) {
+    const item = {
+        ...toNodeSummaryJson(node),
+    };
+    if (body !== undefined) {
+        item.body = body;
+    }
+    return item;
+}
+function toSkillSummaryJson(skill) {
+    return {
+        slug: skill.slug,
+        id: skill.id,
+        qid: skill.qid,
+        ws: skill.ws,
+        type: skill.type,
+        name: skill.name,
+        description: skill.description,
+        tags: [...skill.tags],
+        version: skill.version,
+        authors: [...skill.authors],
+        links: [...skill.links],
+        path: skill.path,
+        has_scripts: skill.has_scripts,
+        has_references: skill.has_references,
+        ochatr: { ...skill.ochatr },
+    };
+}
+function toSkillDetailJson(skill, body) {
+    const item = {
+        ...toSkillSummaryJson(skill),
+    };
+    if (body !== undefined) {
+        item.body = body;
+    }
+    return item;
+}
+function writeJson(payload) {
+    console.log(JSON.stringify(payload, null, 2));
+}
+function writeCount(count, note) {
+    console.error(`count: ${count}`);
+    if (note) {
+        console.error(`note: ${note}`);
+    }
+}

package/dist/commands/search.js

@@ -7,6 +7,7 @@ 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");
+const query_output_1 = require("./query_output");
 function normalizeWorkspace(value) {
     if (!value || value === "all") {
         return undefined;
@@ -25,6 +26,7 @@ function buildSearchText(node) {
         ...node.artifacts,
         ...node.refs,
         ...node.aliases,
+        ...node.skills,
     ];
     return tokens.join(" ").toLowerCase();
 }
@@ -47,6 +49,10 @@ function runSearchCommand(options) {
     if (ws && !config.workspaces[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
+    const normalizedType = options.type?.toLowerCase();
+    if (normalizedType === "skill") {
+        throw new errors_1.UsageError("--type skill is no longer supported here; use `mdkg skill search`");
+    }
     const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
         root: options.root,
         config,
@@ -57,13 +63,24 @@ function runSearchCommand(options) {
         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), {
+    const nodeResults = (0, filter_1.filterNodes)(Object.values(index.nodes), {
         ws,
-        type: options.type,
+        type: normalizedType,
         status: options.status,
-    });
-    const matches = filtered.filter((node) => matchesQuery(node, terms));
-    const sorted = (0, sort_1.sortNodesByQid)(matches);
+        tags: options.tags,
+        tagsMode: options.tagsMode,
+    }).filter((node) => matchesQuery(node, terms));
+    const sorted = (0, sort_1.sortNodesByQid)(nodeResults);
+    if (options.json) {
+        (0, query_output_1.writeJson)({
+            command: "search",
+            kind: "node",
+            count: sorted.length,
+            items: sorted.map(query_output_1.toNodeSummaryJson),
+        });
+        return;
+    }
+    (0, query_output_1.writeCount)(sorted.length, sorted.length === 0 ? `no nodes matched query "${query}"` : undefined);
     for (const node of sorted) {
         console.log((0, node_card_1.formatNodeCard)(node));
     }

package/dist/commands/show.js

@@ -12,6 +12,7 @@ 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");
+const query_output_1 = require("./query_output");
 function normalizeWorkspace(value) {
     if (!value || value === "all") {
         return undefined;
@@ -30,6 +31,10 @@ function runShowCommand(options) {
     if (ws && !config.workspaces[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
+    const normalizedId = options.id.toLowerCase();
+    if (normalizedId.startsWith("skill:") || normalizedId.startsWith("root:skill:")) {
+        throw new errors_1.UsageError(`generic skill show is no longer supported; use \`mdkg skill show ${options.id.replace(/^root:skill:|^skill:/i, "")}\``);
+    }
     const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
         root: options.root,
         config,
@@ -44,6 +49,23 @@ function runShowCommand(options) {
         throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("id", options.id, resolved, ws));
     }
     const node = index.nodes[resolved.qid];
+    const filePath = path_1.default.resolve(options.root, node.path);
+    let body = "";
+    if (!options.metaOnly) {
+        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");
+        body = (0, frontmatter_1.parseFrontmatter)(content, filePath).body.trimEnd();
+    }
+    if (options.json) {
+        (0, query_output_1.writeJson)({
+            command: "show",
+            kind: "node",
+            item: (0, query_output_1.toNodeDetailJson)(node, options.metaOnly ? undefined : body),
+        });
+        return;
+    }
     const lines = [];
     lines.push((0, node_card_1.formatNodeCard)(node));
     const metaLines = [
@@ -53,6 +75,7 @@ function runShowCommand(options) {
         maybeLine("artifacts", node.artifacts),
         maybeLine("refs", node.refs),
         maybeLine("aliases", node.aliases),
+        maybeLine("skills", node.skills),
     ].filter((line) => Boolean(line));
     lines.push(...metaLines);
     if (node.edges.epic) {
@@ -79,17 +102,9 @@ function runShowCommand(options) {
     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);
-        }
+    if (!options.metaOnly && body.length > 0) {
+        lines.push("");
+        lines.push(body);
     }
     console.log(lines.join("\n"));
 }