mdkg 0.0.7 → 0.0.9

package/dist/commands/checkpoint.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCheckpoint = createCheckpoint;
 exports.runCheckpointNewCommand = runCheckpointNewCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -76,7 +77,7 @@ function normalizeWorkspace(value) {
     }
     return normalized;
 }
-function runCheckpointNewCommand(options) {
+function createCheckpoint(options) {
     const title = options.title.trim();
     if (!title) {
         throw new errors_1.UsageError("checkpoint title cannot be empty");
@@ -140,5 +141,21 @@ function runCheckpointNewCommand(options) {
         runId: options.runId,
         now,
     });
-    console.log(`checkpoint created: ${ws}:${id} (${path_1.default.relative(options.root, filePath)})`);
+    return {
+        workspace: ws,
+        id,
+        qid: `${ws}:${id}`,
+        path: path_1.default.relative(options.root, filePath),
+    };
+}
+function runCheckpointNewCommand(options) {
+    const checkpoint = createCheckpoint(options);
+    if (options.json) {
+        console.log(JSON.stringify({
+            action: "created",
+            checkpoint,
+        }, null, 2));
+        return;
+    }
+    console.log(`checkpoint created: ${checkpoint.qid} (${checkpoint.path})`);
 }

package/dist/commands/event.js

@@ -6,6 +6,14 @@ const event_support_1 = require("./event_support");
 const errors_1 = require("../util/errors");
 function runEventEnableCommand(options) {
     const result = (0, event_support_1.ensureEventsEnabled)(options);
+    if (options.json) {
+        console.log(JSON.stringify({
+            action: "enabled",
+            workspace: result.ws,
+            created: result.created,
+        }, null, 2));
+        return;
+    }
     const createdLabel = result.created ? "created" : "already present";
     console.log(`event logging enabled: ${result.ws} (${createdLabel})`);
 }
@@ -41,5 +49,9 @@ function runEventAppendCommand(options) {
         skill: options.skill,
         tool: options.tool,
     });
+    if (options.json) {
+        console.log(JSON.stringify({ action: "appended", event: record }, null, 2));
+        return;
+    }
     console.log(`event appended: ${record.workspace}:${record.kind} (${record.run_id})`);
 }

package/dist/commands/new.js

@@ -9,6 +9,7 @@ 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 agent_file_types_1 = require("../graph/agent_file_types");
 const indexer_1 = require("../graph/indexer");
 const loader_1 = require("../templates/loader");
 const date_1 = require("../util/date");
@@ -44,6 +45,13 @@ function normalizeIdRef(value, key) {
     }
     return normalized;
 }
+function normalizeAgentFileId(value) {
+    const normalized = value.toLowerCase();
+    if (!(0, id_1.isPortableId)(normalized)) {
+        throw new errors_1.UsageError("--id must be a lowercase portable id for agent workflow file types");
+    }
+    return normalized;
+}
 function normalizeList(raw) {
     return parseCsvList(raw);
 }
@@ -110,6 +118,9 @@ function idPrefixForType(type) {
     if (type === "checkpoint") {
         return "chk";
     }
+    if (type === "work_order") {
+        return "order";
+    }
     return type;
 }
 function folderForType(type) {
@@ -122,8 +133,17 @@ function folderForType(type) {
     if (node_1.WORK_TYPES.has(type)) {
         return "work";
     }
+    if ((0, agent_file_types_1.isAgentFileType)(type)) {
+        return "work";
+    }
     throw new errors_1.UsageError(`unsupported type: ${type}`);
 }
+function fileNameForType(type, id, slug) {
+    if ((0, agent_file_types_1.isAgentFileType)(type)) {
+        return path_1.default.join(`${id}-${slug}`, agent_file_types_1.AGENT_FILE_BASENAMES[type]);
+    }
+    return `${id}-${slug}.md`;
+}
 function ensureExists(index, value, ws, label) {
     const resolved = (0, qid_1.resolveQid)(index, value, ws);
     if (resolved.status !== "ok") {
@@ -152,10 +172,18 @@ function runNewCommand(options) {
         useCache: !noCache,
         allowReindex: !noReindex,
     });
+    if (options.id !== undefined && !(0, agent_file_types_1.isAgentFileType)(type)) {
+        throw new errors_1.UsageError("--id is only valid for agent workflow file types");
+    }
     const prefix = idPrefixForType(type);
-    const id = nextIdForPrefix(index.nodes, ws, prefix);
+    const id = options.id !== undefined
+        ? normalizeAgentFileId(options.id)
+        : nextIdForPrefix(index.nodes, ws, prefix);
+    if (index.nodes[`${ws}:${id}`]) {
+        throw new errors_1.UsageError(`node already exists: ${ws}:${id}`);
+    }
     const slug = slugifyTitle(title);
-    const fileName = `${id}-${slug}.md`;
+    const fileName = fileNameForType(type, id, slug);
     const wsEntry = config.workspaces[ws];
     const folder = folderForType(type);
     const targetDir = path_1.default.resolve(options.root, wsEntry.path, wsEntry.mdkg_dir, folder);
@@ -283,7 +311,7 @@ function runNewCommand(options) {
         created: today,
         updated: today,
     });
-    fs_1.default.mkdirSync(targetDir, { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.dirname(filePath), { 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 });
@@ -300,5 +328,23 @@ function runNewCommand(options) {
         runId: options.runId,
         now: options.now,
     });
-    console.log(`node created: ${ws}:${id} (${path_1.default.relative(options.root, filePath)})`);
+    const relativePath = path_1.default.relative(options.root, filePath);
+    const receipt = {
+        workspace: ws,
+        id,
+        qid: `${ws}:${id}`,
+        path: relativePath,
+        type,
+        title,
+        ...(status ? { status } : {}),
+        ...(priority !== undefined ? { priority } : {}),
+    };
+    if (options.json) {
+        console.log(JSON.stringify({
+            action: "created",
+            node: receipt,
+        }, null, 2));
+        return;
+    }
+    console.log(`node created: ${receipt.qid} (${receipt.path})`);
 }

package/dist/commands/pack.js

@@ -106,6 +106,19 @@ function renderSkillMetaBody(skill) {
     }
     lines.push(`has_scripts: ${skill.has_scripts ? "true" : "false"}`);
     lines.push(`has_references: ${skill.has_references ? "true" : "false"}`);
+    for (const [namespace, values] of Object.entries(skill.extensions).sort(([a], [b]) => a.localeCompare(b))) {
+        for (const [key, value] of Object.entries(values).sort(([a], [b]) => a.localeCompare(b))) {
+            if (Array.isArray(value)) {
+                lines.push(`extensions.${namespace}.${key}: ${value.join(", ")}`);
+            }
+            else if (typeof value === "boolean") {
+                lines.push(`extensions.${namespace}.${key}: ${value ? "true" : "false"}`);
+            }
+            else {
+                lines.push(`extensions.${namespace}.${key}: ${value}`);
+            }
+        }
+    }
     for (const [key, value] of Object.entries(skill.ochatr).sort(([a], [b]) => a.localeCompare(b))) {
         if (Array.isArray(value)) {
             lines.push(`${key}: ${value.join(", ")}`);
@@ -170,6 +183,7 @@ function appendSkillsToPack(pack, skillEntries, depth, root) {
         artifacts: [],
         refs: [],
         aliases: [skill.slug, ...skill.tags],
+        attributes: {},
         body: depth === "full" ? loadSkillFullBody(root, skill) : renderSkillMetaBody(skill),
     }));
     if (newNodes.length === 0) {

package/dist/commands/query_output.js

@@ -25,6 +25,7 @@ function toNodeSummaryJson(node) {
         refs: [...node.refs],
         aliases: [...node.aliases],
         skills: [...node.skills],
+        attributes: { ...(node.attributes ?? {}) },
         path: node.path,
         edges: {
             epic: node.edges.epic,
@@ -62,6 +63,7 @@ function toSkillSummaryJson(skill) {
         path: skill.path,
         has_scripts: skill.has_scripts,
         has_references: skill.has_references,
+        extensions: JSON.parse(JSON.stringify(skill.extensions)),
         ochatr: { ...skill.ochatr },
     };
 }

package/dist/commands/search.js

@@ -15,9 +15,16 @@ function normalizeWorkspace(value) {
     return value;
 }
 function buildSearchText(node) {
+    const attributeTokens = Object.entries(node.attributes ?? {}).flatMap(([key, value]) => {
+        if (Array.isArray(value)) {
+            return [key, ...value];
+        }
+        return [key, String(value)];
+    });
     const tokens = [
         node.id,
         node.qid,
+        node.type,
         node.title,
         node.path,
         ...node.tags,
@@ -27,6 +34,7 @@ function buildSearchText(node) {
         ...node.refs,
         ...node.aliases,
         ...node.skills,
+        ...attributeTokens,
     ];
     return tokens.join(" ").toLowerCase();
 }

package/dist/commands/show.js

@@ -25,6 +25,12 @@ function maybeLine(label, values) {
     }
     return `${label}: ${values.join(", ")}`;
 }
+function formatAttributeLine(key, value) {
+    if (Array.isArray(value)) {
+        return `${key}: ${value.join(", ")}`;
+    }
+    return `${key}: ${String(value)}`;
+}
 function runShowCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
@@ -79,6 +85,7 @@ function runShowCommand(options) {
         maybeLine("skills", node.skills),
     ].filter((line) => Boolean(line));
     lines.push(...metaLines);
+    lines.push(...Object.entries(node.attributes ?? {}).map(([key, value]) => formatAttributeLine(key, value)));
     if (node.edges.epic) {
         lines.push(`epic: ${node.edges.epic}`);
     }

package/dist/commands/skill.js

@@ -99,6 +99,16 @@ function filterSkills(skills, tags, tagsMode = "any") {
     });
 }
 function buildSkillSearchText(skill) {
+    const extensionTokens = Object.entries(skill.extensions).flatMap(([namespace, values]) => Object.entries(values).flatMap(([key, value]) => {
+        const field = `extensions.${namespace}.${key}`;
+        if (Array.isArray(value)) {
+            return [field, ...value];
+        }
+        if (typeof value === "boolean") {
+            return [field, value ? "true" : "false"];
+        }
+        return [field, value];
+    }));
     const ochatrTokens = Object.entries(skill.ochatr).flatMap(([key, value]) => {
         if (Array.isArray(value)) {
             return [key, ...value];
@@ -118,6 +128,7 @@ function buildSkillSearchText(skill) {
         ...skill.tags,
         ...skill.authors,
         ...skill.links,
+        ...extensionTokens,
         ...ochatrTokens,
     ];
     return tokens.join(" ").toLowerCase();
@@ -191,7 +202,23 @@ function runSkillNewCommand(options) {
         skill: slug,
         now: options.now,
     });
-    console.log(`skill created: root:skill:${slug} (${path_1.default.relative(root, canonicalPath)})`);
+    const receipt = {
+        workspace: "root",
+        id: `skill:${slug}`,
+        qid: `root:skill:${slug}`,
+        slug,
+        name,
+        path: path_1.default.relative(root, canonicalPath),
+        with_scripts: Boolean(options.withScripts),
+    };
+    if (options.json) {
+        console.log(JSON.stringify({
+            action: "created",
+            skill: receipt,
+        }, null, 2));
+        return;
+    }
+    console.log(`skill created: ${receipt.qid} (${receipt.path})`);
 }
 function runSkillListCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
@@ -274,6 +301,19 @@ function runSkillShowCommand(options) {
         }
         lines.push(`has_scripts: ${skill.has_scripts ? "true" : "false"}`);
         lines.push(`has_references: ${skill.has_references ? "true" : "false"}`);
+        for (const [namespace, values] of Object.entries(skill.extensions).sort(([a], [b]) => a.localeCompare(b))) {
+            for (const [key, value] of Object.entries(values).sort(([a], [b]) => a.localeCompare(b))) {
+                if (Array.isArray(value)) {
+                    lines.push(`extensions.${namespace}.${key}: ${value.join(", ")}`);
+                    continue;
+                }
+                if (typeof value === "boolean") {
+                    lines.push(`extensions.${namespace}.${key}: ${value ? "true" : "false"}`);
+                    continue;
+                }
+                lines.push(`extensions.${namespace}.${key}: ${value}`);
+            }
+        }
         for (const [key, value] of Object.entries(skill.ochatr).sort(([a], [b]) => a.localeCompare(b))) {
             if (Array.isArray(value)) {
                 lines.push(`${key}: ${value.join(", ")}`);
@@ -329,8 +369,11 @@ function runSkillValidateCommand(options) {
     const targetSlug = options.slug?.trim().toLowerCase();
     const warnings = [];
     const errors = [];
+    let checkedCount = 0;
     if (targetSlug) {
-        const result = validateSingleSkill(options.root, normalizeSlug(targetSlug));
+        const normalizedSlug = normalizeSlug(targetSlug);
+        const result = validateSingleSkill(options.root, normalizedSlug);
+        checkedCount = 1;
         warnings.push(...result.warnings);
         errors.push(...result.errors);
     }
@@ -338,31 +381,49 @@ function runSkillValidateCommand(options) {
         const skillsRoot = (0, skills_indexer_1.resolveSkillsRoot)(options.root, config);
         if (fs_1.default.existsSync(skillsRoot)) {
             const entries = fs_1.default.readdirSync(skillsRoot, { withFileTypes: true });
-            for (const entry of entries.filter((value) => value.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
+            const skillDirs = entries
+                .filter((value) => value.isDirectory())
+                .sort((a, b) => a.name.localeCompare(b.name));
+            checkedCount = skillDirs.length;
+            for (const entry of skillDirs) {
                 const result = validateSingleSkill(options.root, entry.name.toLowerCase());
                 warnings.push(...result.warnings);
                 errors.push(...result.errors);
             }
         }
     }
-    for (const warning of Array.from(new Set(warnings))) {
+    const uniqueWarnings = Array.from(new Set(warnings));
+    const uniqueErrors = Array.from(new Set(errors));
+    const receipt = {
+        action: "validated",
+        ok: uniqueErrors.length === 0,
+        checked_count: checkedCount,
+        warning_count: uniqueWarnings.length,
+        error_count: uniqueErrors.length,
+        warnings: uniqueWarnings,
+        errors: uniqueErrors,
+        ...(targetSlug ? { target: normalizeSlug(targetSlug) } : {}),
+    };
+    if (options.json) {
+        console.log(JSON.stringify(receipt, null, 2));
+        if (uniqueErrors.length > 0) {
+            throw new errors_1.ValidationError(`skill validation failed with ${uniqueErrors.length} error(s)`);
+        }
+        return;
+    }
+    for (const warning of uniqueWarnings) {
         console.error(`warning: ${warning}`);
     }
-    if (errors.length > 0) {
-        for (const error of Array.from(new Set(errors))) {
+    if (uniqueErrors.length > 0) {
+        for (const error of uniqueErrors) {
             console.error(error);
         }
-        throw new errors_1.ValidationError(`skill validation failed with ${Array.from(new Set(errors)).length} error(s)`);
+        throw new errors_1.ValidationError(`skill validation failed with ${uniqueErrors.length} error(s)`);
     }
     if (targetSlug) {
         console.log(`skill validation ok: ${targetSlug} (1 skill checked)`);
         return;
     }
-    const checkedCount = fs_1.default.existsSync((0, skills_indexer_1.resolveSkillsRoot)(options.root, config))
-        ? fs_1.default
-            .readdirSync((0, skills_indexer_1.resolveSkillsRoot)(options.root, config), { withFileTypes: true })
-            .filter((value) => value.isDirectory()).length
-        : 0;
     console.log(`skill validation ok: ${checkedCount} skill${checkedCount === 1 ? "" : "s"} checked`);
 }
 function runSkillSyncCommand(options) {
@@ -373,5 +434,12 @@ function runSkillSyncCommand(options) {
         createRoots: true,
         force: options.force,
     });
+    if (options.json) {
+        console.log(JSON.stringify({
+            action: "synced",
+            sync: result,
+        }, null, 2));
+        return;
+    }
     console.log(`skill mirror sync ok: ${result.synced} synced, ${result.pruned} pruned across ${result.targets} target${result.targets === 1 ? "" : "s"}`);
 }

package/dist/commands/task.js

@@ -175,6 +175,30 @@ function maybeWarnEventsDisabled(root, config, ws) {
     }
     console.error(`note: events.jsonl is missing for workspace ${ws}; run mdkg event enable --ws ${ws} to restore JSONL provenance`);
 }
+function taskReceipt(root, loaded) {
+    const rawPriority = loaded.frontmatter.priority;
+    const priority = rawPriority === undefined ? undefined : Number.parseInt(String(rawPriority), 10);
+    return {
+        workspace: loaded.ws,
+        id: loaded.id,
+        qid: loaded.qid,
+        path: path_1.default.relative(root, loaded.filePath),
+        type: loaded.type,
+        status: String(loaded.frontmatter.status ?? ""),
+        ...(Number.isInteger(priority) ? { priority } : {}),
+    };
+}
+function printTaskMutationReceipt(action, root, loaded, json, checkpoint) {
+    if (json) {
+        console.log(JSON.stringify({
+            action,
+            task: taskReceipt(root, loaded),
+            ...(checkpoint ? { checkpoint } : {}),
+        }, null, 2));
+        return;
+    }
+    console.log(`task ${action}: ${loaded.qid}`);
+}
 function runTaskStartCommand(options) {
     const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
     const now = options.now ?? new Date();
@@ -193,7 +217,7 @@ function runTaskStartCommand(options) {
         now,
     });
     maybeWarnEventsDisabled(options.root, loaded.config, loaded.ws);
-    console.log(`task started: ${loaded.qid}`);
+    printTaskMutationReceipt("started", options.root, loaded, options.json);
 }
 function runTaskUpdateCommand(options) {
     const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
@@ -235,7 +259,7 @@ function runTaskUpdateCommand(options) {
         runId: options.runId,
         now,
     });
-    console.log(`task updated: ${loaded.qid}`);
+    printTaskMutationReceipt("updated", options.root, loaded, options.json);
 }
 function runTaskDoneCommand(options) {
     const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
@@ -260,7 +284,20 @@ function runTaskDoneCommand(options) {
         runId: options.runId,
         now,
     });
-    if (options.checkpoint) {
+    let checkpoint;
+    if (options.checkpoint && options.json) {
+        checkpoint = (0, checkpoint_1.createCheckpoint)({
+            root: options.root,
+            title: options.checkpoint,
+            ws: loaded.ws,
+            relates: loaded.id,
+            scope: loaded.id,
+            runId: options.runId,
+            note: `checkpoint created from mdkg task done for ${loaded.id}`,
+            now,
+        });
+    }
+    else if (options.checkpoint) {
         (0, checkpoint_1.runCheckpointNewCommand)({
             root: options.root,
             title: options.checkpoint,
@@ -274,5 +311,5 @@ function runTaskDoneCommand(options) {
     }
     maybeReindex(options.root, loaded.config);
     maybeWarnEventsDisabled(options.root, loaded.config, loaded.ws);
-    console.log(`task done: ${loaded.qid}`);
+    printTaskMutationReceipt("done", options.root, loaded, options.json, checkpoint);
 }

package/dist/commands/validate.js

@@ -65,6 +65,13 @@ const RECOMMENDED_HEADINGS = {
         "Rollout plan",
     ],
     dec: ["Context", "Decision", "Alternatives considered", "Consequences", "Links / references"],
+    spec: ["Purpose", "Runtime", "Work Contracts", "Capabilities"],
+    work: ["Capability", "Inputs", "Outputs", "Receipt"],
+    work_order: ["Request", "Inputs", "Constraints"],
+    receipt: ["Outcome", "Artifacts", "Notes"],
+    feedback: ["Feedback", "Evidence"],
+    dispute: ["Dispute", "Evidence", "Resolution"],
+    proposal: ["Summary", "Evidence", "Proposed Change", "Review"],
 };
 function normalizeHeading(value) {
     return value.trim().toLowerCase();
@@ -119,6 +126,7 @@ function buildIndexNode(root, ws, filePath, node) {
         refs: node.refs,
         aliases: node.aliases,
         skills: node.skills,
+        attributes: node.attributes,
         path: path_1.default.relative(root, filePath),
         edges: normalizeEdges(node.edges, ws),
     };
@@ -256,11 +264,10 @@ function runValidateCommand(options) {
         nodes,
         reverse_edges: {},
     };
-    const graphErrors = (0, validate_graph_1.collectGraphErrors)(index, { allowMissing: false });
-    errors.push(...graphErrors);
+    let knownSkills = new Set();
     try {
         const skillsIndex = (0, skills_indexer_1.buildSkillsIndex)(options.root, config);
-        const knownSkills = new Set(Object.keys(skillsIndex.skills));
+        knownSkills = new Set(Object.keys(skillsIndex.skills));
         for (const node of Object.values(nodes)) {
             for (const slug of node.skills) {
                 if (!knownSkills.has(slug)) {
@@ -273,6 +280,11 @@ function runValidateCommand(options) {
         const message = err instanceof Error ? err.message : "unknown skill validation error";
         errors.push(message);
     }
+    const graphErrors = (0, validate_graph_1.collectGraphErrors)(index, {
+        allowMissing: false,
+        knownSkillSlugs: knownSkills,
+    });
+    errors.push(...graphErrors);
     const skillsRoot = (0, skills_indexer_1.resolveSkillsRoot)(options.root, config);
     for (const dirPath of listDirectories(skillsRoot)) {
         const canonicalPath = path_1.default.join(dirPath, "SKILL.md");
@@ -305,6 +317,22 @@ function runValidateCommand(options) {
         fs_1.default.mkdirSync(path_1.default.dirname(outPath), { recursive: true });
         fs_1.default.writeFileSync(outPath, reportLines.join("\n"), "utf8");
     }
+    const receipt = {
+        action: "validated",
+        ok: uniqueErrors.length === 0,
+        warning_count: uniqueWarnings.length,
+        error_count: uniqueErrors.length,
+        warnings: uniqueWarnings,
+        errors: uniqueErrors,
+        ...(outPath ? { report_path: outPath } : {}),
+    };
+    if (options.json) {
+        console.log(JSON.stringify(receipt, null, 2));
+        if (uniqueErrors.length > 0) {
+            throw new errors_1.ValidationError(`validation failed with ${uniqueErrors.length} error(s)`);
+        }
+        return;
+    }
     if (!options.quiet) {
         for (const warning of uniqueWarnings) {
             console.error(`warning: ${warning}`);