mdkg 0.0.8 → 0.1.0

package/dist/commands/new.js

@@ -9,8 +9,8 @@ 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 template_schema_1 = require("../graph/template_schema");
 const loader_1 = require("../templates/loader");
 const date_1 = require("../util/date");
 const errors_1 = require("../util/errors");
@@ -45,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);
 }
@@ -111,6 +118,9 @@ function idPrefixForType(type) {
     if (type === "checkpoint") {
         return "chk";
     }
+    if (type === "work_order") {
+        return "order";
+    }
     return type;
 }
 function folderForType(type) {
@@ -123,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") {
@@ -153,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);
@@ -173,7 +200,7 @@ function runNewCommand(options) {
             throw new errors_1.UsageError(`--status must be one of ${Array.from(allowed).join(", ")}`);
         }
     }
-    else if (node_1.DEC_TYPES.has(type)) {
+    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(", ")}`);
@@ -197,20 +224,12 @@ function runNewCommand(options) {
     else if (options.priority !== undefined) {
         throw new errors_1.UsageError("--priority is only valid for work items");
     }
-    const graphFields = [
-        ["epic", options.epic],
-        ["parent", options.parent],
-        ["prev", options.prev],
-        ["next", options.next],
-        ["blocked_by", options.blockedBy],
-        ["blocks", options.blocks],
-    ];
-    for (const [key, raw] of graphFields) {
-        if (raw && !(0, template_schema_1.schemaAllowsKey)(type, key)) {
-            throw new errors_1.UsageError(`--${key.replace("_", "-")} is not valid for ${type} nodes`);
+    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 && !(0, template_schema_1.schemaAllowsKey)(type, "cases")) {
+    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;
@@ -228,7 +247,7 @@ function runNewCommand(options) {
     const skills = normalizeSkillList(options.skills);
     const links = normalizeList(options.links);
     const artifacts = normalizeList(options.artifacts);
-    if (skills.length > 0 && !(0, template_schema_1.schemaAllowsKey)(type, "skills")) {
+    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) {
@@ -267,7 +286,6 @@ function runNewCommand(options) {
     }
     const today = (0, date_1.formatDate)(options.now ?? new Date());
     const template = (0, loader_1.loadTemplate)(options.root, config, type, options.template);
-    const schema = (0, template_schema_1.getNodeSchema)(type);
     const content = (0, loader_1.renderTemplate)(template, {
         id,
         type,
@@ -292,8 +310,8 @@ function runNewCommand(options) {
         supersedes: options.supersedes ? options.supersedes.toLowerCase() : undefined,
         created: today,
         updated: today,
-    }, schema?.allowedKeys);
-    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 });
@@ -310,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

@@ -9,12 +9,10 @@ exports.runTaskDoneCommand = runTaskDoneCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../core/config");
-const node_1 = require("../graph/node");
 const indexer_1 = require("../graph/indexer");
 const index_cache_1 = require("../graph/index_cache");
 const frontmatter_1 = require("../graph/frontmatter");
 const skills_indexer_1 = require("../graph/skills_indexer");
-const template_schema_1 = require("../graph/template_schema");
 const date_1 = require("../util/date");
 const errors_1 = require("../util/errors");
 const qid_1 = require("../util/qid");
@@ -114,12 +112,7 @@ function loadMutableTaskNode(root, idOrQid, wsHint) {
     }
     const filePath = path_1.default.resolve(root, node.path);
     const content = fs_1.default.readFileSync(filePath, "utf8");
-    const parsed = (0, node_1.parseNode)(content, filePath, {
-        workStatusEnum: config.work.status_enum,
-        priorityMin: config.work.priority_min,
-        priorityMax: config.work.priority_max,
-        templateSchemas: (0, template_schema_1.loadTemplateSchemas)(root, config, node_1.ALLOWED_TYPES),
-    });
+    const parsed = (0, frontmatter_1.parseFrontmatter)(content, filePath);
     return {
         config,
         index,
@@ -182,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();
@@ -200,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);
@@ -242,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);
@@ -267,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,
@@ -281,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);
 }