mdkg 0.1.0 → 0.1.2

package/dist/templates/loader.js

@@ -6,26 +6,19 @@ 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;
-}
+const builtin_1 = require("./builtin");
 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 templatePath = (0, builtin_1.resolveLocalTemplatePath)(root, config, type, templateSet);
+    if (!fs_1.default.existsSync(templatePath) && templateSet !== undefined) {
+        throw new errors_1.NotFoundError(`template not found: ${templateSet.toLowerCase()}/${(0, builtin_1.templateNameForType)(type)}.md`);
     }
-    const content = fs_1.default.readFileSync(templatePath, "utf8");
-    const { frontmatter, body } = (0, frontmatter_1.parseFrontmatter)(content, templatePath);
-    return { templatePath, frontmatter, body };
+    const source = fs_1.default.existsSync(templatePath) ? "local" : "bundled";
+    const resolvedPath = source === "local" ? templatePath : (0, builtin_1.requireBundledTemplatePath)(type);
+    const content = fs_1.default.readFileSync(resolvedPath, "utf8");
+    const { frontmatter, body } = (0, frontmatter_1.parseFrontmatter)(content, resolvedPath);
+    return { templatePath: resolvedPath, source, frontmatter, body };
 }
 function isTokenPlaceholder(value) {
     return typeof value === "string" && /^\{\{[a-z0-9_]+\}\}$/.test(value);

package/dist/util/argparse.js

@@ -15,6 +15,7 @@ const VALUE_FLAGS = new Set([
     "--edges",
     "--format",
     "--out",
+    "--output",
     "--relates",
     "--scope",
     "--blocked-by",
@@ -51,10 +52,37 @@ const VALUE_FLAGS = new Set([
     "--add-blocked-by",
     "--checkpoint",
     "--kind",
+    "--title",
+    "--agent-id",
+    "--inputs",
+    "--outputs",
+    "--required-capabilities",
+    "--pricing-model",
+    "--work-id",
+    "--requester",
+    "--request-ref",
+    "--input-refs",
+    "--requested-outputs",
+    "--constraint-refs",
+    "--receipt-status",
+    "--work-order-id",
+    "--outcome",
+    "--cost-ref",
+    "--proof-refs",
+    "--attestation-refs",
+    "--input-hashes",
+    "--output-hashes",
+    "--add-input-refs",
+    "--add-proof-refs",
+    "--add-attestation-refs",
     "--notes",
     "--agent",
     "--skill",
     "--tool",
+    "--visibility",
+    "--source-path",
+    "--source-repo",
+    "--max-stale-seconds",
 ]);
 const BOOLEAN_FLAGS = new Set([
     "--tolerant",
@@ -87,10 +115,12 @@ const BOOLEAN_FLAGS = new Set([
     "--list-profiles",
     "--with-scripts",
     "--clear-blocked-by",
+    "--all",
 ]);
 const FLAG_ALIASES = {
     "--o": "--out",
     "-o": "--out",
+    "--output": "--out",
     "--profile": "--pack-profile",
     "--f": "--format",
     "-f": "--format",

package/dist/util/refs.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUriRef = isUriRef;
+exports.archiveIdFromUri = archiveIdFromUri;
+exports.isArchiveUri = isArchiveUri;
+exports.isSha256Ref = isSha256Ref;
+exports.isPortableOrUriRef = isPortableOrUriRef;
+exports.validatePortableOrUriRef = validatePortableOrUriRef;
+const id_1 = require("./id");
+const URI_RE = /^[a-z][a-z0-9+.-]*:\/\/\S+$/i;
+const ARCHIVE_URI_RE = /^archive:\/\/([a-z][a-z0-9_]*(?:[._-][a-z0-9_]+)*)$/;
+const SHA256_RE = /^sha256:[a-f0-9]{64}$/;
+function isUriRef(value) {
+    return URI_RE.test(value);
+}
+function archiveIdFromUri(value) {
+    const match = ARCHIVE_URI_RE.exec(value);
+    if (!match) {
+        return undefined;
+    }
+    return match[1];
+}
+function isArchiveUri(value) {
+    return archiveIdFromUri(value) !== undefined;
+}
+function isSha256Ref(value) {
+    return SHA256_RE.test(value);
+}
+function isPortableOrUriRef(value) {
+    return (0, id_1.isPortableId)(value.toLowerCase()) || isUriRef(value);
+}
+function validatePortableOrUriRef(value) {
+    if (isUriRef(value)) {
+        if (value.startsWith("archive://")) {
+            return archiveIdFromUri(value) !== undefined;
+        }
+        return true;
+    }
+    return value === value.toLowerCase() && (0, id_1.isPortableId)(value);
+}

package/dist/util/zip.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeterministicZip = createDeterministicZip;
+exports.createDeterministicZipFromEntries = createDeterministicZipFromEntries;
+exports.readZipEntries = readZipEntries;
+exports.readSingleFileZip = readSingleFileZip;
+const zlib_1 = __importDefault(require("zlib"));
+const CRC_TABLE = new Uint32Array(256);
+for (let i = 0; i < 256; i += 1) {
+    let value = i;
+    for (let bit = 0; bit < 8; bit += 1) {
+        value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+    }
+    CRC_TABLE[i] = value >>> 0;
+}
+function crc32(data) {
+    let crc = 0xffffffff;
+    for (const byte of data) {
+        crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function dosDate1980() {
+    return {
+        time: 0,
+        date: (0 << 9) | (1 << 5) | 1,
+    };
+}
+function headerBuffer(size) {
+    return Buffer.alloc(size);
+}
+function createDeterministicZip(entryName, data) {
+    return createDeterministicZipFromEntries([{ name: entryName, data }]);
+}
+function normalizeEntryName(entryName) {
+    const normalizedName = entryName.split(/[\\/]/).filter(Boolean).join("/");
+    if (!normalizedName || normalizedName.includes("..")) {
+        throw new Error("zip entry name must be a relative file name");
+    }
+    return normalizedName;
+}
+function createDeterministicZipFromEntries(entries) {
+    if (entries.length === 0) {
+        throw new Error("zip must contain at least one entry");
+    }
+    const normalizedEntries = entries
+        .map((entry) => ({ name: normalizeEntryName(entry.name), data: entry.data }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const seen = new Set();
+    for (const entry of normalizedEntries) {
+        if (seen.has(entry.name)) {
+            throw new Error(`duplicate zip entry: ${entry.name}`);
+        }
+        seen.add(entry.name);
+    }
+    const localRecords = [];
+    const centralRecords = [];
+    let localOffset = 0;
+    const timestamp = dosDate1980();
+    for (const entry of normalizedEntries) {
+        const nameBuffer = Buffer.from(entry.name, "utf8");
+        const compressed = zlib_1.default.deflateRawSync(entry.data, { level: 9 });
+        const crc = crc32(entry.data);
+        const local = headerBuffer(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4);
+        local.writeUInt16LE(0, 6);
+        local.writeUInt16LE(8, 8);
+        local.writeUInt16LE(timestamp.time, 10);
+        local.writeUInt16LE(timestamp.date, 12);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(compressed.length, 18);
+        local.writeUInt32LE(entry.data.length, 22);
+        local.writeUInt16LE(nameBuffer.length, 26);
+        local.writeUInt16LE(0, 28);
+        const central = headerBuffer(46);
+        central.writeUInt32LE(0x02014b50, 0);
+        central.writeUInt16LE(20, 4);
+        central.writeUInt16LE(20, 6);
+        central.writeUInt16LE(0, 8);
+        central.writeUInt16LE(8, 10);
+        central.writeUInt16LE(timestamp.time, 12);
+        central.writeUInt16LE(timestamp.date, 14);
+        central.writeUInt32LE(crc, 16);
+        central.writeUInt32LE(compressed.length, 20);
+        central.writeUInt32LE(entry.data.length, 24);
+        central.writeUInt16LE(nameBuffer.length, 28);
+        central.writeUInt16LE(0, 30);
+        central.writeUInt16LE(0, 32);
+        central.writeUInt16LE(0, 34);
+        central.writeUInt16LE(0, 36);
+        central.writeUInt32LE(0, 38);
+        central.writeUInt32LE(localOffset, 42);
+        const localRecord = Buffer.concat([local, nameBuffer, compressed]);
+        localRecords.push(localRecord);
+        centralRecords.push(Buffer.concat([central, nameBuffer]));
+        localOffset += localRecord.length;
+    }
+    const localPayload = Buffer.concat(localRecords);
+    const centralPayload = Buffer.concat(centralRecords);
+    const end = headerBuffer(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(0, 4);
+    end.writeUInt16LE(0, 6);
+    end.writeUInt16LE(normalizedEntries.length, 8);
+    end.writeUInt16LE(normalizedEntries.length, 10);
+    end.writeUInt32LE(centralPayload.length, 12);
+    end.writeUInt32LE(localPayload.length, 16);
+    end.writeUInt16LE(0, 20);
+    return Buffer.concat([localPayload, centralPayload, end]);
+}
+function readZipEntries(zip) {
+    const entries = [];
+    let offset = 0;
+    while (offset + 4 <= zip.length) {
+        const signature = zip.readUInt32LE(offset);
+        if (signature === 0x02014b50 || signature === 0x06054b50) {
+            break;
+        }
+        if (signature !== 0x04034b50) {
+            throw new Error("zip local header missing");
+        }
+        const method = zip.readUInt16LE(offset + 8);
+        const compressedSize = zip.readUInt32LE(offset + 18);
+        const uncompressedSize = zip.readUInt32LE(offset + 22);
+        const nameLength = zip.readUInt16LE(offset + 26);
+        const extraLength = zip.readUInt16LE(offset + 28);
+        const nameStart = offset + 30;
+        const dataOffset = nameStart + nameLength + extraLength;
+        const entryName = zip.slice(nameStart, nameStart + nameLength).toString("utf8");
+        const compressed = zip.slice(dataOffset, dataOffset + compressedSize);
+        const data = method === 8 ? zlib_1.default.inflateRawSync(compressed) : method === 0 ? compressed : undefined;
+        if (!data) {
+            throw new Error(`unsupported zip compression method: ${method}`);
+        }
+        if (data.length !== uncompressedSize) {
+            throw new Error("zip uncompressed size mismatch");
+        }
+        entries.push({ name: entryName, data });
+        offset = dataOffset + compressedSize;
+    }
+    return entries;
+}
+function readSingleFileZip(zip) {
+    const entries = readZipEntries(zip);
+    if (entries.length !== 1) {
+        throw new Error("zip must contain exactly one file");
+    }
+    return { entryName: entries[0].name, data: entries[0].data };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdkg",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Markdown Knowledge Graph",
   "license": "MIT",
   "bin": {
@@ -14,10 +14,16 @@
     "smoke:consumer": "npm run build && node scripts/smoke-consumer.js",
     "smoke:matrix": "npm run build && node scripts/smoke-command-matrix.js",
     "smoke:upgrade": "npm run build && node scripts/smoke-upgrade.js",
+    "smoke:init": "npm run build && node scripts/smoke-init.js",
+    "smoke:capabilities": "npm run build && node scripts/smoke-capabilities.js",
+    "smoke:archive-work": "npm run build && node scripts/smoke-archive-work.js",
+    "smoke:bundle": "npm run build && node scripts/smoke-bundle.js",
+    "smoke:bundle-import": "npm run build && node scripts/smoke-bundle-import.js",
+    "smoke:visibility": "npm run build && node scripts/smoke-visibility.js",
     "cli:snapshot": "npm run build && node scripts/cli_help_snapshot.js",
     "cli:check": "npm run build && node scripts/cli_help_snapshot.js --check",
     "prepack": "npm run build && node scripts/assert-publish-ready.js",
-    "prepublishOnly": "npm run test && npm run cli:check && node dist/cli.js validate && npm run smoke:consumer && npm run smoke:matrix && npm run smoke:upgrade && node scripts/assert-publish-ready.js",
+    "prepublishOnly": "npm run test && npm run cli:check && node dist/cli.js validate && npm run smoke:consumer && npm run smoke:matrix && npm run smoke:upgrade && npm run smoke:init && npm run smoke:capabilities && npm run smoke:archive-work && npm run smoke:bundle && npm run smoke:bundle-import && npm run smoke:visibility && node scripts/assert-publish-ready.js",
     "postinstall": "node scripts/postinstall.js"
   },
   "devDependencies": {