mdkg 0.0.3 → 0.0.5

package/dist/pack/pack.js

@@ -130,6 +130,24 @@ function buildPackNode(root, index, qid) {
 function mergeWarnings(warnings, message) {
     warnings.push(message);
 }
+function checkpointWorkspaceFromQid(qid) {
+    const [workspace] = qid.split(":");
+    return workspace ?? "root";
+}
+function resolveLatestCheckpointQid(index, workspace) {
+    const candidates = Object.values(index.nodes)
+        .filter((node) => node.ws === workspace && node.type === "checkpoint")
+        .sort((a, b) => {
+        if (a.updated !== b.updated) {
+            return b.updated.localeCompare(a.updated);
+        }
+        if (a.created !== b.created) {
+            return b.created.localeCompare(a.created);
+        }
+        return b.qid.localeCompare(a.qid);
+    });
+    return candidates[0]?.qid;
+}
 function applyMaxNodes(orderedQids, maxNodes, truncation) {
     if (maxNodes <= 0 || orderedQids.length <= maxNodes) {
         return { included: orderedQids, dropped: [] };
@@ -142,7 +160,22 @@ function applyMaxNodes(orderedQids, maxNodes, truncation) {
 }
 function buildPack(options) {
     const warnings = [];
+    const includeLatestCheckpoint = options.includeLatestCheckpoint ?? true;
     const { qids, depths } = collectNodes(options.index, options.rootQid, options.depth, options.edges);
+    const workspace = checkpointWorkspaceFromQid(options.rootQid);
+    const latestCheckpointHint = options.index.meta.latest_checkpoint_qid?.[workspace];
+    const latestCheckpointResolved = includeLatestCheckpoint
+        ? resolveLatestCheckpointQid(options.index, workspace)
+        : undefined;
+    if (latestCheckpointResolved && latestCheckpointResolved !== options.rootQid) {
+        qids.add(latestCheckpointResolved);
+    }
+    if (includeLatestCheckpoint &&
+        latestCheckpointHint &&
+        latestCheckpointResolved &&
+        latestCheckpointHint !== latestCheckpointResolved) {
+        mergeWarnings(warnings, `latest_checkpoint_qid hint mismatch for ${workspace}: ${latestCheckpointHint} -> ${latestCheckpointResolved}`);
+    }
     if (options.verbose) {
         const coreIds = (0, verbose_core_1.readVerboseCoreList)(options.verboseCoreListPath);
         for (const id of coreIds) {
@@ -173,6 +206,8 @@ function buildPack(options) {
             verbose: options.verbose,
             generated_at: new Date().toISOString(),
             node_count: nodes.length,
+            latest_checkpoint_qid: latestCheckpointResolved,
+            latest_checkpoint_qid_hint: latestCheckpointHint,
             truncated: truncation,
         },
         nodes,

package/dist/util/argparse.js

@@ -36,6 +36,24 @@ const VALUE_FLAGS = new Set([
     "--max-tokens",
     "--stats-out",
     "--truncation-report",
+    "--description",
+    "--authors",
+    "--links",
+    "--tags-mode",
+    "--run-id",
+    "--note",
+    "--add-artifacts",
+    "--add-links",
+    "--add-refs",
+    "--add-skills",
+    "--add-tags",
+    "--add-blocked-by",
+    "--checkpoint",
+    "--kind",
+    "--notes",
+    "--agent",
+    "--skill",
+    "--tool",
 ]);
 const BOOLEAN_FLAGS = new Set([
     "--tolerant",
@@ -44,14 +62,17 @@ const BOOLEAN_FLAGS = new Set([
     "--quiet",
     "--no-cache",
     "--no-reindex",
+    "--no-update-ignores",
     "--force",
     "--update-gitignore",
     "--update-npmignore",
     "--update-dockerignore",
+    "--agent",
     "--agents",
     "--claude",
     "--llm",
     "--body",
+    "--meta",
     "--strip-code",
     "--stats",
     "--concise",
@@ -59,10 +80,14 @@ const BOOLEAN_FLAGS = new Set([
     "--dry-run",
     "--json",
     "--list-profiles",
+    "--with-scripts",
+    "--clear-blocked-by",
+    "--no-update-gitignore",
 ]);
 const FLAG_ALIASES = {
     "--o": "--out",
     "-o": "--out",
+    "--profile": "--pack-profile",
     "--f": "--format",
     "-f": "--format",
     "--v": "--verbose",
@@ -143,13 +168,15 @@ function parseArgs(argv) {
                 result.flags[flag] = value;
                 continue;
             }
-            if (BOOLEAN_FLAGS.has(flag)) {
-                result.flags[flag] = true;
-                continue;
-            }
             const value = inlineValue ?? argv[i + 1];
-            if (VALUE_FLAGS.has(flag)) {
+            const supportsValue = VALUE_FLAGS.has(flag);
+            const supportsBoolean = BOOLEAN_FLAGS.has(flag);
+            if (supportsValue) {
                 if (value === undefined || isFlagToken(value)) {
+                    if (supportsBoolean) {
+                        result.flags[flag] = true;
+                        continue;
+                    }
                     result.flags[flag] = true;
                     continue;
                 }
@@ -159,6 +186,10 @@ function parseArgs(argv) {
                 result.flags[flag] = NORMALIZE_VALUE_FLAGS.has(flag) ? value.toLowerCase() : value;
                 continue;
             }
+            if (supportsBoolean) {
+                result.flags[flag] = true;
+                continue;
+            }
             if (value === undefined || isFlagToken(value)) {
                 result.flags[flag] = true;
                 continue;

package/dist/util/filter.js

@@ -1,7 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterNodes = filterNodes;
+function matchesTags(nodeTags, filterTags, mode) {
+    if (!filterTags || filterTags.length === 0) {
+        return true;
+    }
+    if (nodeTags.length === 0) {
+        return false;
+    }
+    const nodeSet = new Set(nodeTags.map((value) => value.toLowerCase()));
+    if (mode === "all") {
+        return filterTags.every((value) => nodeSet.has(value));
+    }
+    return filterTags.some((value) => nodeSet.has(value));
+}
 function filterNodes(nodes, filters) {
+    const normalizedTags = filters.tags?.map((value) => value.toLowerCase()).filter(Boolean) ?? [];
+    const tagsMode = filters.tagsMode ?? "any";
     return nodes.filter((node) => {
         if (filters.ws && node.ws !== filters.ws) {
             return false;
@@ -21,6 +36,9 @@ function filterNodes(nodes, filters) {
         if (filters.blocked && node.status !== "blocked") {
             return false;
         }
+        if (!matchesTags(node.tags, normalizedTags, tagsMode)) {
+            return false;
+        }
         return true;
     });
 }

package/dist/util/id.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCanonicalId = isCanonicalId;
+exports.isCanonicalIdRef = isCanonicalIdRef;
+const NUMERIC_ID_RE = /^[a-z]+-[0-9]+$/;
+const WORKSPACE_RE = /^[a-z][a-z0-9_]*$/;
+const SPECIAL_IDS = new Set(["rule-guide", "rule-soul", "rule-human"]);
+function isCanonicalId(value) {
+    return NUMERIC_ID_RE.test(value) || SPECIAL_IDS.has(value);
+}
+function isCanonicalIdRef(value) {
+    const normalized = value.toLowerCase();
+    const parts = normalized.split(":");
+    if (parts.length === 1) {
+        return isCanonicalId(parts[0] ?? "");
+    }
+    if (parts.length !== 2) {
+        return false;
+    }
+    const workspace = parts[0] ?? "";
+    const id = parts[1] ?? "";
+    return WORKSPACE_RE.test(workspace) && isCanonicalId(id);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdkg",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Markdown Knowledge Graph",
   "license": "MIT",
   "bin": {
@@ -10,7 +10,10 @@
     "build": "tsc -p tsconfig.build.json && node scripts/add-shebang.js && node scripts/copy-init-assets.js",
     "build:test": "tsc -p tsconfig.test.json",
     "test": "npm run build && npm run build:test && node --test dist/tests/**/*.test.js",
-    "smoke:consumer": "npm run build && node scripts/smoke-consumer.js"
+    "test:coverage": "npm run build && npm run build:test && node --test --experimental-test-coverage dist/tests/**/*.test.js",
+    "smoke:consumer": "npm run build && node scripts/smoke-consumer.js",
+    "cli:snapshot": "npm run build && node scripts/cli_help_snapshot.js",
+    "cli:check": "npm run build && node scripts/cli_help_snapshot.js --check"
   },
   "devDependencies": {
     "@types/node": "^18.19.0",