mdkg 0.0.1 → 0.0.2

package/dist/util/argparse.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+const NORMALIZE_VALUE_FLAGS = new Set(["--ws", "--type", "--status", "--template", "--epic"]);
+const VALUE_FLAGS = new Set([
+    "--root",
+    "--ws",
+    "--type",
+    "--status",
+    "--template",
+    "--epic",
+    "--priority",
+    "--depth",
+    "--edges",
+    "--format",
+    "--out",
+    "--relates",
+    "--scope",
+    "--blocked-by",
+    "--blocks",
+    "--prev",
+    "--next",
+    "--links",
+    "--artifacts",
+    "--refs",
+    "--aliases",
+    "--tags",
+    "--owners",
+    "--supersedes",
+    "--cases",
+    "--mdkg-dir",
+]);
+const BOOLEAN_FLAGS = new Set([
+    "--tolerant",
+    "--blocked",
+    "--body",
+    "--verbose",
+    "--quiet",
+    "--no-cache",
+    "--no-reindex",
+    "--force",
+    "--update-gitignore",
+    "--update-npmignore",
+    "--update-dockerignore",
+    "--agents",
+    "--claude",
+    "--llm",
+]);
+const FLAG_ALIASES = {
+    "--o": "--out",
+    "-o": "--out",
+    "--f": "--format",
+    "-f": "--format",
+    "--v": "--verbose",
+    "-v": "--verbose",
+    "--d": "--depth",
+    "-d": "--depth",
+    "--e": "--edges",
+    "-e": "--edges",
+    "--w": "--ws",
+    "-w": "--ws",
+    "--r": "--root",
+    "-r": "--root",
+    "--q": "--quiet",
+    "-q": "--quiet",
+};
+function normalizeFlag(flag) {
+    return FLAG_ALIASES[flag] ?? flag;
+}
+function normalizeFlagToken(token) {
+    if (!token.startsWith("-")) {
+        return undefined;
+    }
+    let normalized = token;
+    if (!normalized.startsWith("--") && normalized.length === 2) {
+        normalized = `--${normalized.slice(1)}`;
+    }
+    const eqIndex = normalized.indexOf("=");
+    const flag = eqIndex === -1 ? normalized : normalized.slice(0, eqIndex);
+    return normalizeFlag(flag);
+}
+function isFlagToken(token) {
+    const flag = normalizeFlagToken(token);
+    if (!flag) {
+        return false;
+    }
+    return VALUE_FLAGS.has(flag) || BOOLEAN_FLAGS.has(flag) || flag === "--help";
+}
+function parseArgs(argv) {
+    const result = {
+        help: false,
+        positionals: [],
+        flags: {},
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--help" || arg === "-h") {
+            result.help = true;
+            continue;
+        }
+        let normalizedArg = arg;
+        if (normalizedArg.startsWith("-") && !normalizedArg.startsWith("--")) {
+            if (normalizedArg.length === 2) {
+                normalizedArg = `--${normalizedArg.slice(1)}`;
+            }
+        }
+        if (normalizedArg.startsWith("--")) {
+            const eqIndex = normalizedArg.indexOf("=");
+            const flagRaw = eqIndex === -1 ? normalizedArg : normalizedArg.slice(0, eqIndex);
+            const flag = normalizeFlag(flagRaw);
+            const inlineValue = eqIndex === -1 ? undefined : normalizedArg.slice(eqIndex + 1);
+            if (flag === "--root") {
+                const value = inlineValue ?? argv[i + 1];
+                if (!value || isFlagToken(value)) {
+                    result.error = "--root requires a path";
+                    return result;
+                }
+                if (inlineValue === undefined) {
+                    i += 1;
+                }
+                result.root = value;
+                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)) {
+                if (value === undefined || isFlagToken(value)) {
+                    result.flags[flag] = true;
+                    continue;
+                }
+                if (inlineValue === undefined) {
+                    i += 1;
+                }
+                result.flags[flag] = NORMALIZE_VALUE_FLAGS.has(flag) ? value.toLowerCase() : value;
+                continue;
+            }
+            if (value === undefined || isFlagToken(value)) {
+                result.flags[flag] = true;
+                continue;
+            }
+            if (inlineValue === undefined) {
+                i += 1;
+            }
+            result.flags[flag] = NORMALIZE_VALUE_FLAGS.has(flag) ? value.toLowerCase() : value;
+            continue;
+        }
+        result.positionals.push(arg);
+    }
+    return result;
+}

package/dist/util/date.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDate = formatDate;
+function formatDate(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}

package/dist/util/errors.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = exports.ValidationError = exports.UsageError = void 0;
+class UsageError extends Error {
+}
+exports.UsageError = UsageError;
+class ValidationError extends Error {
+}
+exports.ValidationError = ValidationError;
+class NotFoundError extends Error {
+}
+exports.NotFoundError = NotFoundError;

package/dist/util/filter.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterNodes = filterNodes;
+function filterNodes(nodes, filters) {
+    return nodes.filter((node) => {
+        if (filters.ws && node.ws !== filters.ws) {
+            return false;
+        }
+        if (filters.type && node.type !== filters.type) {
+            return false;
+        }
+        if (filters.status && node.status !== filters.status) {
+            return false;
+        }
+        if (filters.epic && node.edges.epic !== filters.epic) {
+            return false;
+        }
+        if (filters.priority !== undefined && node.priority !== filters.priority) {
+            return false;
+        }
+        if (filters.blocked && node.status !== "blocked") {
+            return false;
+        }
+        return true;
+    });
+}

package/dist/util/output.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACK_WARN_BYTES = void 0;
+exports.shouldWarnLargeOutput = shouldWarnLargeOutput;
+exports.formatLargeOutputWarning = formatLargeOutputWarning;
+exports.sanitizeFilename = sanitizeFilename;
+exports.formatTimestampForFilename = formatTimestampForFilename;
+exports.buildDefaultPackPath = buildDefaultPackPath;
+const path_1 = __importDefault(require("path"));
+exports.PACK_WARN_BYTES = 200000;
+function shouldWarnLargeOutput(bytes, isTTY) {
+    return isTTY && bytes >= exports.PACK_WARN_BYTES;
+}
+function formatLargeOutputWarning(bytes) {
+    return `warning: pack output is large (${bytes} bytes); consider --out <path> to write to a file`;
+}
+function sanitizeFilename(value) {
+    return value.replace(/[^a-z0-9_-]/gi, "-");
+}
+function formatTimestampForFilename(date, useUtc = false) {
+    const pad = (value, size) => String(value).padStart(size, "0");
+    const year = useUtc ? date.getUTCFullYear() : date.getFullYear();
+    const month = useUtc ? date.getUTCMonth() + 1 : date.getMonth() + 1;
+    const day = useUtc ? date.getUTCDate() : date.getDate();
+    const hours = useUtc ? date.getUTCHours() : date.getHours();
+    const minutes = useUtc ? date.getUTCMinutes() : date.getMinutes();
+    const seconds = useUtc ? date.getUTCSeconds() : date.getSeconds();
+    const millis = useUtc ? date.getUTCMilliseconds() : date.getMilliseconds();
+    return [
+        year,
+        pad(month, 2),
+        pad(day, 2),
+        "-",
+        pad(hours, 2),
+        pad(minutes, 2),
+        pad(seconds, 2),
+        pad(millis, 3),
+    ].join("");
+}
+function buildDefaultPackPath(root, rootId, format, verbose, now) {
+    const kind = verbose ? "verbose" : "standard";
+    const safeId = sanitizeFilename(rootId.toLowerCase());
+    const safeFormat = sanitizeFilename(format.toLowerCase());
+    const timestamp = formatTimestampForFilename(now);
+    const filename = `pack_${kind}_${safeId}_${timestamp}.${safeFormat}`;
+    return path_1.default.resolve(root, ".mdkg", "pack", filename);
+}

package/dist/util/qid.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatResolveError = formatResolveError;
+exports.resolveQid = resolveQid;
+function formatResolveError(label, value, result, wsHint) {
+    switch (result.status) {
+        case "missing": {
+            if (wsHint) {
+                if (result.candidates.length > 0) {
+                    return `${label} not found in workspace ${wsHint}: ${value} (did you mean ${result.candidates.join(", ")}?)`;
+                }
+                return `${label} not found in workspace ${wsHint}: ${value}`;
+            }
+            return `${label} not found: ${value}`;
+        }
+        case "ambiguous": {
+            const candidates = result.candidates.join(", ");
+            return `ambiguous ${label}: ${value} (use ${candidates})`;
+        }
+        case "ok": {
+            return `${label} resolved: ${result.qid}`;
+        }
+    }
+}
+function resolveQid(index, idOrQid, wsHint) {
+    const normalized = idOrQid.toLowerCase();
+    if (normalized.includes(":")) {
+        if (index.nodes[normalized]) {
+            return { status: "ok", qid: normalized };
+        }
+        return { status: "missing", candidates: [] };
+    }
+    const matches = Object.values(index.nodes)
+        .filter((node) => node.id === normalized)
+        .map((node) => node.qid)
+        .sort();
+    if (wsHint) {
+        const wsMatches = matches.filter((qid) => qid.startsWith(`${wsHint}:`));
+        if (wsMatches.length === 1) {
+            return { status: "ok", qid: wsMatches[0] };
+        }
+        if (wsMatches.length > 1) {
+            return { status: "ambiguous", candidates: wsMatches };
+        }
+        return { status: "missing", candidates: matches };
+    }
+    if (matches.length === 1) {
+        return { status: "ok", qid: matches[0] };
+    }
+    if (matches.length === 0) {
+        return { status: "missing", candidates: [] };
+    }
+    return { status: "ambiguous", candidates: matches };
+}

package/dist/util/sort.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortNodesByQid = sortNodesByQid;
+exports.sortNodesForNext = sortNodesForNext;
+exports.sortIndexNodes = sortIndexNodes;
+function sortNodesByQid(nodes) {
+    return [...nodes].sort((a, b) => a.qid.localeCompare(b.qid));
+}
+function rankPriority(node, priorityMax) {
+    return node.priority === undefined ? priorityMax + 1 : node.priority;
+}
+function rankStatus(node, statusRanks) {
+    if (!node.status) {
+        return statusRanks.size;
+    }
+    return statusRanks.get(node.status) ?? statusRanks.size;
+}
+function sortNodesForNext(nodes, options) {
+    const statusRanks = new Map(options.statusPreference.map((status, index) => [status, index]));
+    return [...nodes].sort((a, b) => {
+        const priorityA = rankPriority(a, options.priorityMax);
+        const priorityB = rankPriority(b, options.priorityMax);
+        if (priorityA !== priorityB) {
+            return priorityA - priorityB;
+        }
+        const statusA = rankStatus(a, statusRanks);
+        const statusB = rankStatus(b, statusRanks);
+        if (statusA !== statusB) {
+            return statusA - statusB;
+        }
+        return a.qid.localeCompare(b.qid);
+    });
+}
+function sortIndexNodes(nodes) {
+    const sorted = {};
+    for (const qid of Object.keys(nodes).sort()) {
+        sorted[qid] = nodes[qid];
+    }
+    return sorted;
+}

package/package.json

@@ -1,13 +1,29 @@
 {
   "name": "mdkg",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Markdown Knowledge Graph",
   "license": "MIT",
   "bin": {
     "mdkg": "dist/cli.js"
   },
+  "scripts": {
+    "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"
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.0",
+    "typescript": "^5.4.0"
+  },
   "files": [
-    "dist/",
+    "dist/cli.js",
+    "dist/commands/",
+    "dist/core/",
+    "dist/graph/",
+    "dist/init/",
+    "dist/pack/",
+    "dist/templates/",
+    "dist/util/",
     "README.md",
     "LICENSE"
   ],