mdkg 0.0.2 → 0.0.4

package/dist/commands/pack.js

@@ -8,16 +8,25 @@ 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 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");
+const export_md_1 = require("../pack/export_md");
 const export_toon_1 = require("../pack/export_toon");
 const export_xml_1 = require("../pack/export_xml");
+const metrics_1 = require("../pack/metrics");
+const pack_1 = require("../pack/pack");
+const profile_1 = require("../pack/profile");
+const stats_1 = require("../pack/stats");
+const headings_1 = require("../templates/headings");
+const errors_1 = require("../util/errors");
+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;
@@ -42,6 +51,205 @@ 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");
+}
+function resolveStatsPath(root, outPath, statsOut) {
+    if (statsOut) {
+        return path_1.default.resolve(root, statsOut);
+    }
+    return `${outPath}.stats.json`;
+}
+function shouldWriteTruncationReport(pack, options) {
+    if (options.truncationReport) {
+        return true;
+    }
+    if (!options.maxChars && !options.maxLines && !options.maxTokens) {
+        return false;
+    }
+    const hasDrops = pack.meta.truncated.dropped.length > 0;
+    const hasBodyTruncation = (pack.meta.truncated.body_truncated ?? []).length > 0;
+    return hasDrops || hasBodyTruncation;
+}
+function printDryRunSummary(pack, stats, format) {
+    console.log("dry-run: no files written");
+    console.log(`root: ${pack.meta.root}`);
+    console.log(`profile: ${pack.meta.profile ?? "standard"}`);
+    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(", ")}`);
+    }
+    if ((pack.meta.truncated.body_truncated ?? []).length > 0) {
+        console.log(`body_truncated: ${(pack.meta.truncated.body_truncated ?? []).join(", ")}`);
+    }
+    console.log("included_nodes:");
+    for (const node of pack.nodes) {
+        console.log(`- ${node.qid}`);
+    }
+    console.log("");
+    console.log((0, stats_1.renderPackStats)(stats));
+}
 function runPackCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
@@ -67,6 +275,24 @@ 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)({
+            profile: options.packProfile,
+            concise: options.concise,
+            stripCode: options.stripCode,
+            maxCodeLines: options.maxCodeLines,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new errors_1.UsageError(message);
+    }
+    if (options.verbose && resolvedProfile.profile !== "standard") {
+        throw new errors_1.UsageError("--verbose is only supported with --profile standard");
+    }
     const buildResult = (0, pack_1.buildPack)({
         root: options.root,
         index,
@@ -77,29 +303,125 @@ 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)(packWithSkills, {
+        resolved: resolvedProfile,
+        templateHeadingMap,
+    });
+    let budgeted;
+    try {
+        budgeted = (0, budget_1.applyPackBudgets)(shaped, {
+            maxChars: options.maxChars,
+            maxLines: options.maxLines,
+            maxTokens: options.maxTokens,
+        }, resolvedProfile.profile);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new errors_1.UsageError(message);
+    }
+    let finalPack = budgeted.pack;
     const format = normalizeFormat(options.format);
     let output = "";
     if (format === "md") {
-        output = (0, export_md_1.exportMarkdown)(buildResult.pack, config.pack.limits.max_bytes).content;
+        const markdown = (0, export_md_1.exportMarkdown)(finalPack, config.pack.limits.max_bytes);
+        output = markdown.content;
+        finalPack = {
+            meta: markdown.meta,
+            nodes: markdown.nodes,
+        };
     }
     else if (format === "json") {
-        output = (0, export_json_1.exportJson)(buildResult.pack);
+        output = (0, export_json_1.exportJson)(finalPack);
     }
     else if (format === "toon") {
-        output = (0, export_toon_1.exportToon)(buildResult.pack);
+        output = (0, export_toon_1.exportToon)(finalPack);
     }
     else if (format === "xml") {
-        output = (0, export_xml_1.exportXml)(buildResult.pack);
+        output = (0, export_xml_1.exportXml)(finalPack);
+    }
+    const finalStats = (0, metrics_1.measurePack)(finalPack);
+    if (options.dryRun) {
+        if (options.out || options.statsOut || options.truncationReport) {
+            console.error("warning: --out/--stats-out/--truncation-report are ignored with --dry-run");
+        }
+        printDryRunSummary(finalPack, finalStats, format);
+        return;
     }
     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());
+        : (0, output_1.buildDefaultPackPath)(options.root, rootId, format, Boolean(options.verbose), new Date(), resolvedProfile.profile);
     fs_1.default.mkdirSync(path_1.default.dirname(outPath), { recursive: true });
     fs_1.default.writeFileSync(outPath, output, "utf8");
     console.log(`pack written: ${outPath}`);
+    const statsEnabled = Boolean(options.stats || options.statsOut);
+    if (statsEnabled) {
+        const statsPayload = {
+            root: finalPack.meta.root,
+            profile: finalPack.meta.profile ?? resolvedProfile.profile,
+            body_mode: finalPack.meta.body_mode ?? resolvedProfile.bodyMode,
+            ...finalStats,
+        };
+        const statsPath = resolveStatsPath(options.root, outPath, options.statsOut);
+        writeJsonFile(statsPath, statsPayload);
+        console.log(`pack stats written: ${statsPath}`);
+        if (options.stats) {
+            console.log((0, stats_1.renderPackStats)(finalStats));
+        }
+    }
+    const truncationReport = {
+        ...budgeted.report,
+        after: {
+            node_count: finalPack.nodes.length,
+            chars: finalStats.totals.chars,
+            lines: finalStats.totals.lines,
+            bytes: finalStats.totals.bytes,
+            tokens_estimate: finalStats.totals.tokens_estimate,
+        },
+        dropped_nodes: [...finalPack.meta.truncated.dropped],
+        body_truncated_nodes: [...(finalPack.meta.truncated.body_truncated ?? [])],
+    };
+    if (shouldWriteTruncationReport(finalPack, options)) {
+        const reportPath = options.truncationReport
+            ? path_1.default.resolve(options.root, options.truncationReport)
+            : `${outPath}.truncation.json`;
+        writeJsonFile(reportPath, truncationReport);
+        console.log(`pack truncation report written: ${reportPath}`);
+    }
 }

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"));
 }