mdkg 0.0.8 → 0.1.0

package/dist/core/config.js

@@ -3,10 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfigSchema = validateConfigSchema;
 exports.loadConfig = loadConfig;
 const fs_1 = __importDefault(require("fs"));
 const paths_1 = require("./paths");
 const migrate_1 = require("./migrate");
+const workspace_path_1 = require("./workspace_path");
+const WORKSPACE_ALIAS_RE = /^[a-z][a-z0-9_]*$/;
+const PACK_EDGE_KEYS = new Set([
+    "parent",
+    "epic",
+    "relates",
+    "blocked_by",
+    "blocks",
+    "prev",
+    "next",
+]);
+const NEXT_WORK_STRATEGIES = new Set(["chain_then_priority"]);
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -17,6 +30,17 @@ function requireString(value, path, errors) {
     }
     return value;
 }
+function requireStringInSet(value, path, allowed, errors) {
+    const raw = requireString(value, path, errors);
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (!allowed.has(raw)) {
+        errors.push(`${path} must be one of ${Array.from(allowed).join(", ")}`);
+        return undefined;
+    }
+    return raw;
+}
 function requireBoolean(value, path, errors) {
     if (typeof value !== "boolean") {
         errors.push(`${path} must be a boolean`);
@@ -31,6 +55,39 @@ function requireNumber(value, path, errors) {
     }
     return value;
 }
+function requireInteger(value, path, errors) {
+    const number = requireNumber(value, path, errors);
+    if (number === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(number)) {
+        errors.push(`${path} must be an integer`);
+        return undefined;
+    }
+    return number;
+}
+function requireNonNegativeInteger(value, path, errors) {
+    const integer = requireInteger(value, path, errors);
+    if (integer === undefined) {
+        return undefined;
+    }
+    if (integer < 0) {
+        errors.push(`${path} must be a non-negative integer`);
+        return undefined;
+    }
+    return integer;
+}
+function requirePositiveInteger(value, path, errors) {
+    const integer = requireInteger(value, path, errors);
+    if (integer === undefined) {
+        return undefined;
+    }
+    if (integer <= 0) {
+        errors.push(`${path} must be a positive integer`);
+        return undefined;
+    }
+    return integer;
+}
 function requireStringArray(value, path, errors) {
     if (!Array.isArray(value)) {
         errors.push(`${path} must be an array of strings`);
@@ -46,6 +103,53 @@ function requireStringArray(value, path, errors) {
     }
     return items;
 }
+function requireLowercaseUniqueStringArray(value, path, errors, allowEmpty = false) {
+    const items = requireStringArray(value, path, errors);
+    if (items === undefined) {
+        return undefined;
+    }
+    if (items.length === 0) {
+        if (!allowEmpty) {
+            errors.push(`${path} must not be empty`);
+        }
+        return items;
+    }
+    const seen = new Set();
+    for (let i = 0; i < items.length; i += 1) {
+        const item = items[i];
+        if (item.trim().length === 0) {
+            errors.push(`${path}[${i}] must not be empty`);
+            continue;
+        }
+        if (item !== item.trim()) {
+            errors.push(`${path}[${i}] must not include surrounding whitespace`);
+        }
+        if (item !== item.toLowerCase()) {
+            errors.push(`${path}[${i}] must be lowercase`);
+        }
+        if (seen.has(item)) {
+            errors.push(`${path} must not contain duplicate value "${item}"`);
+            continue;
+        }
+        seen.add(item);
+    }
+    return items;
+}
+function requireKnownLowercaseUniqueStringArray(value, path, allowed, errors, allowEmpty = false) {
+    const items = requireLowercaseUniqueStringArray(value, path, errors, allowEmpty);
+    if (items === undefined) {
+        return undefined;
+    }
+    for (let i = 0; i < items.length; i += 1) {
+        if (items[i].trim().length === 0) {
+            continue;
+        }
+        if (!allowed.has(items[i])) {
+            errors.push(`${path}[${i}] must be one of ${Array.from(allowed).join(", ")}`);
+        }
+    }
+    return items;
+}
 function requireObject(value, path, errors) {
     if (!isObject(value)) {
         errors.push(`${path} must be an object`);
@@ -53,6 +157,29 @@ function requireObject(value, path, errors) {
     }
     return value;
 }
+function validateWorkspaceAlias(alias, errors) {
+    if (alias === "all") {
+        errors.push("workspaces.all alias is reserved");
+        return;
+    }
+    if (alias !== alias.toLowerCase() || !WORKSPACE_ALIAS_RE.test(alias)) {
+        errors.push(`workspaces.${alias} alias must be lowercase and use [a-z0-9_]`);
+    }
+}
+function requireContainedPath(value, path, errors) {
+    const raw = requireString(value, path, errors);
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        return (0, workspace_path_1.normalizeContainedWorkspacePath)(raw, path);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        errors.push(message);
+        return undefined;
+    }
+}
 function validateConfigSchema(raw) {
     const errors = [];
     if (!isObject(raw)) {
@@ -70,50 +197,70 @@ function validateConfigSchema(raw) {
         ? {
             auto_reindex: requireBoolean(indexRaw.auto_reindex, "index.auto_reindex", errors),
             tolerant: requireBoolean(indexRaw.tolerant, "index.tolerant", errors),
-            global_index_path: requireString(indexRaw.global_index_path, "index.global_index_path", errors),
+            global_index_path: requireContainedPath(indexRaw.global_index_path, "index.global_index_path", errors),
         }
         : undefined;
     const packLimitsRaw = packRaw ? requireObject(packRaw.limits, "pack.limits", errors) : undefined;
     const pack = packRaw
         ? {
-            default_depth: requireNumber(packRaw.default_depth, "pack.default_depth", errors),
-            default_edges: requireStringArray(packRaw.default_edges, "pack.default_edges", errors),
-            verbose_core_list_path: requireString(packRaw.verbose_core_list_path, "pack.verbose_core_list_path", errors),
+            default_depth: requireNonNegativeInteger(packRaw.default_depth, "pack.default_depth", errors),
+            default_edges: requireKnownLowercaseUniqueStringArray(packRaw.default_edges, "pack.default_edges", PACK_EDGE_KEYS, errors, true),
+            verbose_core_list_path: requireContainedPath(packRaw.verbose_core_list_path, "pack.verbose_core_list_path", errors),
             limits: packLimitsRaw
                 ? {
-                    max_nodes: requireNumber(packLimitsRaw.max_nodes, "pack.limits.max_nodes", errors),
-                    max_bytes: requireNumber(packLimitsRaw.max_bytes, "pack.limits.max_bytes", errors),
+                    max_nodes: requirePositiveInteger(packLimitsRaw.max_nodes, "pack.limits.max_nodes", errors),
+                    max_bytes: requirePositiveInteger(packLimitsRaw.max_bytes, "pack.limits.max_bytes", errors),
                 }
                 : undefined,
         }
         : undefined;
     const templates = templatesRaw
         ? {
-            root_path: requireString(templatesRaw.root_path, "templates.root_path", errors),
+            root_path: requireContainedPath(templatesRaw.root_path, "templates.root_path", errors),
             default_set: requireString(templatesRaw.default_set, "templates.default_set", errors),
             workspace_overrides_enabled: requireBoolean(templatesRaw.workspace_overrides_enabled, "templates.workspace_overrides_enabled", errors),
         }
         : undefined;
     const workNextRaw = workRaw ? requireObject(workRaw.next, "work.next", errors) : undefined;
     const work = workRaw
-        ? {
-            status_enum: requireStringArray(workRaw.status_enum, "work.status_enum", errors),
-            priority_min: requireNumber(workRaw.priority_min, "work.priority_min", errors),
-            priority_max: requireNumber(workRaw.priority_max, "work.priority_max", errors),
-            next: workNextRaw
-                ? {
-                    strategy: requireString(workNextRaw.strategy, "work.next.strategy", errors),
-                    status_preference: requireStringArray(workNextRaw.status_preference, "work.next.status_preference", errors),
+        ? (() => {
+            const statusEnum = requireLowercaseUniqueStringArray(workRaw.status_enum, "work.status_enum", errors);
+            const priorityMin = requireInteger(workRaw.priority_min, "work.priority_min", errors);
+            const priorityMax = requireInteger(workRaw.priority_max, "work.priority_max", errors);
+            if (priorityMin !== undefined &&
+                priorityMax !== undefined &&
+                priorityMin > priorityMax) {
+                errors.push("work.priority_min must be less than or equal to work.priority_max");
+            }
+            const statusPreference = workNextRaw
+                ? requireLowercaseUniqueStringArray(workNextRaw.status_preference, "work.next.status_preference", errors)
+                : undefined;
+            if (statusEnum !== undefined && statusPreference !== undefined) {
+                const allowedStatuses = new Set(statusEnum);
+                for (let i = 0; i < statusPreference.length; i += 1) {
+                    if (!allowedStatuses.has(statusPreference[i])) {
+                        errors.push(`work.next.status_preference[${i}] must be listed in work.status_enum`);
+                    }
                 }
-                : undefined,
-        }
+            }
+            return {
+                status_enum: statusEnum,
+                priority_min: priorityMin,
+                priority_max: priorityMax,
+                next: workNextRaw
+                    ? {
+                        strategy: requireStringInSet(workNextRaw.strategy, "work.next.strategy", NEXT_WORK_STRATEGIES, errors),
+                        status_preference: statusPreference,
+                    }
+                    : undefined,
+            };
+        })()
         : undefined;
     const workspaces = {};
+    const workspaceDocRootOwners = new Map();
     if (workspacesRaw) {
         for (const [alias, entry] of Object.entries(workspacesRaw)) {
-            if (alias !== alias.toLowerCase()) {
-                errors.push(`workspaces.${alias} alias must be lowercase`);
-            }
+            validateWorkspaceAlias(alias, errors);
             const ws = requireObject(entry, `workspaces.${alias}`, errors);
             if (!ws) {
                 continue;
@@ -122,14 +269,62 @@ function validateConfigSchema(raw) {
             const wsEnabled = requireBoolean(ws.enabled, `workspaces.${alias}.enabled`, errors);
             const wsMdkgDir = requireString(ws.mdkg_dir, `workspaces.${alias}.mdkg_dir`, errors);
             if (wsPath && wsEnabled !== undefined && wsMdkgDir) {
+                let normalizedPath;
+                let normalizedMdkgDir;
+                try {
+                    normalizedPath = (0, workspace_path_1.normalizeContainedWorkspacePath)(wsPath, `workspaces.${alias}.path`);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    errors.push(message);
+                }
+                try {
+                    normalizedMdkgDir = (0, workspace_path_1.normalizeContainedWorkspacePath)(wsMdkgDir, `workspaces.${alias}.mdkg_dir`);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    errors.push(message);
+                }
+                if (!normalizedPath || !normalizedMdkgDir) {
+                    continue;
+                }
+                if (alias !== "root" && (0, workspace_path_1.isRootWorkspacePath)(normalizedPath)) {
+                    errors.push(`workspaces.${alias}.path must not be "." for non-root workspaces`);
+                    continue;
+                }
+                const docRootKey = (0, workspace_path_1.workspaceDocumentRootKey)(normalizedPath, normalizedMdkgDir);
+                const existingAlias = workspaceDocRootOwners.get(docRootKey);
+                if (existingAlias) {
+                    errors.push(`workspaces.${alias} document root duplicates workspaces.${existingAlias}`);
+                    continue;
+                }
+                workspaceDocRootOwners.set(docRootKey, alias);
                 workspaces[alias] = {
-                    path: wsPath,
+                    path: normalizedPath,
                     enabled: wsEnabled,
-                    mdkg_dir: wsMdkgDir,
+                    mdkg_dir: normalizedMdkgDir,
                 };
             }
         }
     }
+    const rootWorkspace = workspaces.root;
+    if (root_required !== undefined && root_required !== true) {
+        errors.push("root_required must be true");
+    }
+    if (!rootWorkspace) {
+        errors.push("workspaces.root is required");
+    }
+    else {
+        if (rootWorkspace.path !== ".") {
+            errors.push('workspaces.root.path must be "."');
+        }
+        if (rootWorkspace.enabled !== true) {
+            errors.push("workspaces.root.enabled must be true");
+        }
+        if (rootWorkspace.mdkg_dir !== ".mdkg") {
+            errors.push('workspaces.root.mdkg_dir must be ".mdkg"');
+        }
+    }
     if (errors.length > 0) {
         throw new Error(`config validation failed:\n${errors.join("\n")}`);
     }

package/dist/core/migrate.js

@@ -3,15 +3,49 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LATEST_SCHEMA_VERSION = void 0;
 exports.migrateConfig = migrateConfig;
 exports.LATEST_SCHEMA_VERSION = 1;
-const MIGRATIONS = {};
-function migrateConfig(raw) {
-    if (typeof raw !== "object" || raw === null) {
-        throw new Error("config must be a JSON object");
-    }
+const LEGACY_SCHEMA_VERSION = 0;
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getSchemaVersion(raw) {
     const version = raw.schema_version;
+    if (version === undefined) {
+        return LEGACY_SCHEMA_VERSION;
+    }
     if (typeof version !== "number" || !Number.isInteger(version)) {
         throw new Error("config schema_version must be an integer");
     }
+    if (version < LEGACY_SCHEMA_VERSION) {
+        throw new Error("config schema_version must be non-negative");
+    }
+    return version;
+}
+function migrateLegacyConfig(input) {
+    if (!isJsonObject(input)) {
+        throw new Error("config must be a JSON object");
+    }
+    return {
+        ...input,
+        schema_version: 1,
+        workspaces: input.workspaces === undefined
+            ? {
+                root: {
+                    path: ".",
+                    enabled: true,
+                    mdkg_dir: ".mdkg",
+                },
+            }
+            : input.workspaces,
+    };
+}
+const MIGRATIONS = {
+    [LEGACY_SCHEMA_VERSION]: migrateLegacyConfig,
+};
+function migrateConfig(raw) {
+    if (!isJsonObject(raw)) {
+        throw new Error("config must be a JSON object");
+    }
+    const version = getSchemaVersion(raw);
     if (version > exports.LATEST_SCHEMA_VERSION) {
         throw new Error(`config schema_version ${version} is newer than supported ${exports.LATEST_SCHEMA_VERSION}`);
     }

package/dist/core/version.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackageVersion = readPackageVersion;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function readPackageVersion(startDir = __dirname) {
+    let current = path_1.default.resolve(startDir);
+    for (let i = 0; i < 5; i += 1) {
+        const packagePath = path_1.default.join(current, "package.json");
+        if (fs_1.default.existsSync(packagePath)) {
+            try {
+                const raw = JSON.parse(fs_1.default.readFileSync(packagePath, "utf8"));
+                if (raw.name === "mdkg" && typeof raw.version === "string" && raw.version.trim().length > 0) {
+                    return raw.version;
+                }
+            }
+            catch {
+                return "unknown";
+            }
+        }
+        const parent = path_1.default.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return "unknown";
+}

package/dist/core/workspace_path.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeContainedWorkspacePath = normalizeContainedWorkspacePath;
+exports.isRootWorkspacePath = isRootWorkspacePath;
+exports.workspaceDocumentRootKey = workspaceDocumentRootKey;
+const path_1 = __importDefault(require("path"));
+function isAbsoluteOnSupportedPlatform(value) {
+    return path_1.default.isAbsolute(value) || path_1.default.posix.isAbsolute(value) || path_1.default.win32.isAbsolute(value);
+}
+function normalizeContainedWorkspacePath(value, label) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error(`${label} cannot be empty`);
+    }
+    if (normalized.includes("\0")) {
+        throw new Error(`${label} cannot contain NUL bytes`);
+    }
+    if (isAbsoluteOnSupportedPlatform(normalized)) {
+        throw new Error(`${label} must be relative`);
+    }
+    if (normalized.split(/[\\/]+/).some((part) => part === "..")) {
+        throw new Error(`${label} cannot contain parent-directory components`);
+    }
+    return normalized;
+}
+function isRootWorkspacePath(value) {
+    const parts = value
+        .trim()
+        .split(/[\\/]+/)
+        .filter(Boolean);
+    return parts.length > 0 && parts.every((part) => part === ".");
+}
+function workspaceDocumentRootKey(workspacePath, mdkgDir) {
+    return [workspacePath, mdkgDir]
+        .flatMap((value) => value.trim().split(/[\\/]+/))
+        .filter((part) => part && part !== ".")
+        .join("/");
+}