mdkg 0.1.10 → 0.3.0

package/dist/commands/db.js

@@ -8,6 +8,18 @@ exports.runDbInitCommand = runDbInitCommand;
 exports.runDbMigrateCommand = runDbMigrateCommand;
 exports.runDbVerifyCommand = runDbVerifyCommand;
 exports.runDbStatsCommand = runDbStatsCommand;
+exports.runDbQueueCreateCommand = runDbQueueCreateCommand;
+exports.runDbQueuePauseCommand = runDbQueuePauseCommand;
+exports.runDbQueueResumeCommand = runDbQueueResumeCommand;
+exports.runDbQueueEnqueueCommand = runDbQueueEnqueueCommand;
+exports.runDbQueueClaimCommand = runDbQueueClaimCommand;
+exports.runDbQueueAckCommand = runDbQueueAckCommand;
+exports.runDbQueueFailCommand = runDbQueueFailCommand;
+exports.runDbQueueDeadLetterCommand = runDbQueueDeadLetterCommand;
+exports.runDbQueueReleaseExpiredCommand = runDbQueueReleaseExpiredCommand;
+exports.runDbQueueStatsCommand = runDbQueueStatsCommand;
+exports.runDbQueueListCommand = runDbQueueListCommand;
+exports.runDbQueueShowCommand = runDbQueueShowCommand;
 exports.runDbSnapshotSealCommand = runDbSnapshotSealCommand;
 exports.runDbSnapshotVerifyCommand = runDbSnapshotVerifyCommand;
 exports.runDbSnapshotStatusCommand = runDbSnapshotStatusCommand;
@@ -23,6 +35,7 @@ const paths_1 = require("../core/paths");
 const project_db_1 = require("../core/project_db");
 const project_db_migrations_1 = require("../core/project_db_migrations");
 const project_db_snapshot_1 = require("../core/project_db_snapshot");
+const project_db_queue_1 = require("../core/project_db_queue");
 const version_1 = require("../core/version");
 const index_1 = require("./index");
 const capabilities_indexer_1 = require("../graph/capabilities_indexer");
@@ -449,6 +462,177 @@ function runDbStatsCommand(options) {
         }
     }
 }
+function requireQueueName(options) {
+    if (!options.queueName) {
+        throw new errors_1.UsageError("queue name is required");
+    }
+    return options.queueName;
+}
+function requireMessageId(options) {
+    if (!options.messageId) {
+        throw new errors_1.UsageError("message id is required");
+    }
+    return options.messageId;
+}
+function requireLeaseOwner(options) {
+    if (!options.leaseOwner) {
+        throw new errors_1.UsageError("--lease-owner is required");
+    }
+    return options.leaseOwner;
+}
+function requireLeaseMs(options) {
+    if (options.leaseMs === undefined) {
+        throw new errors_1.UsageError("--lease-ms is required");
+    }
+    return options.leaseMs;
+}
+function loadQueueDatabasePath(root) {
+    const config = (0, config_1.loadConfig)(root);
+    const verification = (0, project_db_migrations_1.verifyProjectDb)(root, config);
+    if (!verification.ok) {
+        throw new errors_1.ValidationError(`db queue requires a valid project DB; run mdkg db verify`);
+    }
+    return (0, project_db_1.resolveConfiguredProjectDbLayout)(root, config.db).runtimeFile;
+}
+function parseQueuePayload(options) {
+    const hasPayloadJson = options.payloadJson !== undefined;
+    const hasPayloadFile = options.payloadFile !== undefined;
+    if (hasPayloadJson === hasPayloadFile) {
+        throw new errors_1.UsageError("mdkg db queue enqueue requires exactly one of --payload-json or --payload-file");
+    }
+    const raw = hasPayloadJson
+        ? options.payloadJson
+        : fs_1.default.readFileSync(path_1.default.resolve(options.root, String(options.payloadFile)), "utf8");
+    try {
+        return JSON.parse(String(raw));
+    }
+    catch (err) {
+        throw new errors_1.UsageError(`queue payload must be valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function writeQueueJsonOrText(action, payload, json) {
+    if (json) {
+        console.log(JSON.stringify({ action, ok: true, ...payload }, null, 2));
+        return;
+    }
+    console.log(action);
+    for (const [key, value] of Object.entries(payload)) {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+            console.log(`${key}: ${value}`);
+        }
+        else {
+            console.log(`${key}: ${JSON.stringify(value)}`);
+        }
+    }
+}
+function runQueueMutation(options, fn, action) {
+    const config = (0, config_1.loadConfig)(options.root);
+    (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => {
+        const databasePath = loadQueueDatabasePath(options.root);
+        writeQueueJsonOrText(action, fn(databasePath), options.json);
+    });
+}
+function runDbQueueCreateCommand(options) {
+    runQueueMutation(options, (databasePath) => (0, project_db_queue_1.createProjectQueue)(databasePath, {
+        queue_name: requireQueueName(options),
+        paused: options.paused,
+        reason: options.reason,
+    }), "db-queue-create");
+}
+function runDbQueuePauseCommand(options) {
+    runQueueMutation(options, (databasePath) => ({ queue: (0, project_db_queue_1.pauseProjectQueue)(databasePath, { queue_name: requireQueueName(options), reason: options.reason }) }), "db-queue-pause");
+}
+function runDbQueueResumeCommand(options) {
+    runQueueMutation(options, (databasePath) => ({ queue: (0, project_db_queue_1.resumeProjectQueue)(databasePath, { queue_name: requireQueueName(options) }) }), "db-queue-resume");
+}
+function runDbQueueEnqueueCommand(options) {
+    runQueueMutation(options, (databasePath) => (0, project_db_queue_1.enqueueProjectQueueMessage)(databasePath, {
+        queue_name: requireQueueName(options),
+        message_id: requireMessageId(options),
+        dedupe_key: options.dedupeKey,
+        payload: parseQueuePayload(options),
+        available_at_ms: options.availableAtMs,
+        max_attempts: options.maxAttempts,
+    }), "db-queue-enqueue");
+}
+function runDbQueueClaimCommand(options) {
+    runQueueMutation(options, (databasePath) => ({
+        message: (0, project_db_queue_1.claimProjectQueueMessage)(databasePath, {
+            queue_name: requireQueueName(options),
+            lease_owner: requireLeaseOwner(options),
+            lease_ms: requireLeaseMs(options),
+        }),
+    }), "db-queue-claim");
+}
+function runDbQueueAckCommand(options) {
+    runQueueMutation(options, (databasePath) => ({
+        message: (0, project_db_queue_1.ackProjectQueueMessage)(databasePath, {
+            queue_name: requireQueueName(options),
+            message_id: requireMessageId(options),
+            lease_owner: requireLeaseOwner(options),
+        }),
+    }), "db-queue-ack");
+}
+function runDbQueueFailCommand(options) {
+    if (!options.error) {
+        throw new errors_1.UsageError("--error is required");
+    }
+    runQueueMutation(options, (databasePath) => ({
+        message: (0, project_db_queue_1.failProjectQueueMessage)(databasePath, {
+            queue_name: requireQueueName(options),
+            message_id: requireMessageId(options),
+            lease_owner: requireLeaseOwner(options),
+            error: String(options.error),
+            retry_after_ms: options.retryAfterMs,
+        }),
+    }), "db-queue-fail");
+}
+function runDbQueueDeadLetterCommand(options) {
+    if (!options.error) {
+        throw new errors_1.UsageError("--error is required");
+    }
+    runQueueMutation(options, (databasePath) => ({
+        message: (0, project_db_queue_1.deadLetterProjectQueueMessage)(databasePath, {
+            queue_name: requireQueueName(options),
+            message_id: requireMessageId(options),
+            lease_owner: requireLeaseOwner(options),
+            error: String(options.error),
+        }),
+    }), "db-queue-dead-letter");
+}
+function runDbQueueReleaseExpiredCommand(options) {
+    runQueueMutation(options, (databasePath) => (0, project_db_queue_1.releaseExpiredProjectQueueLeases)(databasePath, { queue_name: options.queueName }), "db-queue-release-expired");
+}
+function runDbQueueStatsCommand(options) {
+    const databasePath = loadQueueDatabasePath(options.root);
+    const stats = (0, project_db_queue_1.readProjectQueueStats)(databasePath, { queue_name: options.queueName });
+    const queue = options.queueName ? (0, project_db_queue_1.readProjectQueue)(databasePath, options.queueName) : null;
+    writeQueueJsonOrText("db-queue-stats", {
+        queue,
+        stats,
+        queues: options.queueName ? undefined : (0, project_db_queue_1.listProjectQueues)(databasePath),
+        snapshot_summary: (0, project_db_queue_1.readProjectQueueSnapshotSummary)(databasePath),
+    }, options.json);
+}
+function runDbQueueListCommand(options) {
+    const databasePath = loadQueueDatabasePath(options.root);
+    const messages = (0, project_db_queue_1.listProjectQueueMessages)(databasePath, {
+        queue_name: requireQueueName(options),
+        status: (options.status ?? "all"),
+        limit: options.limit,
+    });
+    writeQueueJsonOrText("db-queue-list", { queue_name: requireQueueName(options), count: messages.length, messages }, options.json);
+}
+function runDbQueueShowCommand(options) {
+    const databasePath = loadQueueDatabasePath(options.root);
+    const queueName = requireQueueName(options);
+    const messageId = requireMessageId(options);
+    const message = (0, project_db_queue_1.readProjectQueueMessage)(databasePath, queueName, messageId);
+    if (!message) {
+        throw new errors_1.NotFoundError(`queue message not found: ${queueName}/${messageId}`);
+    }
+    writeQueueJsonOrText("db-queue-show", { message }, options.json);
+}
 function printSnapshotChecks(payload) {
     for (const check of payload.checks) {
         const location = check.path ? ` (${path_1.default.isAbsolute(check.path) ? rel(process.cwd(), check.path) : check.path})` : "";
@@ -457,7 +641,7 @@ function printSnapshotChecks(payload) {
 }
 function runDbSnapshotSealCommandLocked(options) {
     const config = (0, config_1.loadConfig)(options.root);
-    const payload = (0, project_db_snapshot_1.sealProjectDbSnapshot)(options.root, config);
+    const payload = (0, project_db_snapshot_1.sealProjectDbSnapshot)(options.root, config, options.queuePolicy ?? "drain");
     if (options.json) {
         console.log(JSON.stringify(payload, null, 2));
         return;

package/dist/commands/format.js

@@ -37,7 +37,7 @@ const EXTERNAL_REF_LIST_KEYS = new Set([
     "proof_refs",
     "attestation_refs",
 ]);
-const HASH_REF_LIST_KEYS = new Set(["input_hashes", "output_hashes"]);
+const HASH_REF_LIST_KEYS = new Set(["evidence_hashes", "input_hashes", "output_hashes"]);
 function isValidId(value) {
     return (0, id_1.isCanonicalId)(value);
 }

package/dist/commands/spec.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSpecListCommand = runSpecListCommand;
+exports.runSpecShowCommand = runSpecShowCommand;
+exports.runSpecValidateCommand = runSpecValidateCommand;
+const capability_1 = require("./capability");
+const validate_1 = require("./validate");
+const errors_1 = require("../util/errors");
+function sortSpecRecords(records) {
+    return [...records].sort((a, b) => {
+        const qidDelta = a.qid.localeCompare(b.qid);
+        if (qidDelta !== 0) {
+            return qidDelta;
+        }
+        return a.path.localeCompare(b.path);
+    });
+}
+function loadSpecRecords(options) {
+    const listOptions = {
+        root: options.root,
+        kind: "spec",
+        noCache: options.noCache,
+        noReindex: options.noReindex,
+    };
+    return sortSpecRecords((0, capability_1.filterCapabilityRecords)((0, capability_1.loadCapabilityRecords)(listOptions), listOptions));
+}
+function matchesSpecRef(record, id) {
+    const normalized = id.toLowerCase();
+    return (record.id === id ||
+        record.qid === id ||
+        record.path === id ||
+        record.id.toLowerCase() === normalized ||
+        record.qid.toLowerCase() === normalized ||
+        record.path.toLowerCase() === normalized ||
+        record.aliases.some((alias) => alias.toLowerCase() === normalized));
+}
+function resolveSpecRecord(records, id) {
+    const matches = records.filter((record) => matchesSpecRef(record, id));
+    if (matches.length === 1) {
+        return matches[0];
+    }
+    if (matches.length > 1) {
+        throw new errors_1.UsageError(`SPEC reference is ambiguous: ${id}`);
+    }
+    throw new errors_1.NotFoundError(`SPEC not found: ${id}`);
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function stringArrayValue(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function printSpecList(records, json) {
+    if (json) {
+        console.log(JSON.stringify({
+            kind: "spec",
+            count: records.length,
+            items: records,
+        }, null, 2));
+        return;
+    }
+    if (records.length === 0) {
+        console.log("no SPEC.md capabilities found");
+        return;
+    }
+    console.log(`SPEC.md capabilities: ${records.length}`);
+    for (const record of records) {
+        const kind = stringValue(record.spec?.spec_kind);
+        const kindLabel = kind ? ` | ${kind}` : "";
+        console.log(`${record.qid} | ${record.visibility}${kindLabel} | ${record.title}`);
+    }
+}
+function printSpec(record, json) {
+    if (json) {
+        console.log(JSON.stringify({ kind: "spec", item: record }, null, 2));
+        return;
+    }
+    console.log(`${record.qid} | ${record.visibility}`);
+    console.log(`title: ${record.title}`);
+    const specKind = stringValue(record.spec?.spec_kind);
+    if (specKind) {
+        console.log(`spec_kind: ${specKind}`);
+    }
+    console.log(`path: ${record.path}`);
+    const requestedCapabilities = stringArrayValue(record.spec?.requested_capabilities);
+    if (requestedCapabilities.length > 0) {
+        console.log(`requested_capabilities: ${requestedCapabilities.join(", ")}`);
+    }
+}
+function runSpecListCommand(options) {
+    printSpecList(loadSpecRecords(options), options.json);
+}
+function runSpecShowCommand(options) {
+    printSpec(resolveSpecRecord(loadSpecRecords(options), options.id), options.json);
+}
+function runSpecValidateCommand(options) {
+    if (options.id) {
+        resolveSpecRecord(loadSpecRecords(options), options.id);
+    }
+    (0, validate_1.runValidateCommand)({ root: options.root, json: options.json });
+}