mdkg 0.0.2 → 0.0.4

package/dist/commands/task.js

@@ -0,0 +1,270 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTaskStartCommand = runTaskStartCommand;
+exports.runTaskUpdateCommand = runTaskUpdateCommand;
+exports.runTaskDoneCommand = runTaskDoneCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../core/config");
+const indexer_1 = require("../graph/indexer");
+const index_cache_1 = require("../graph/index_cache");
+const frontmatter_1 = require("../graph/frontmatter");
+const skills_indexer_1 = require("../graph/skills_indexer");
+const date_1 = require("../util/date");
+const errors_1 = require("../util/errors");
+const qid_1 = require("../util/qid");
+const id_1 = require("../util/id");
+const event_support_1 = require("./event_support");
+const checkpoint_1 = require("./checkpoint");
+const MUTABLE_TASK_TYPES = new Set(["task", "bug", "test"]);
+const SKILL_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function parseCsvList(raw) {
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+}
+function normalizeWorkspace(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.toLowerCase();
+    if (normalized === "all") {
+        throw new errors_1.UsageError("--ws all is not valid here");
+    }
+    return normalized;
+}
+function normalizeId(value, flag) {
+    const normalized = value.trim().toLowerCase();
+    if (!(0, id_1.isCanonicalId)(normalized)) {
+        throw new errors_1.UsageError(`${flag} entries must match <prefix>-<number> or reserved id: ${value}`);
+    }
+    return normalized;
+}
+function normalizeIdRef(value, flag) {
+    const normalized = value.trim().toLowerCase();
+    if (!(0, id_1.isCanonicalIdRef)(normalized)) {
+        throw new errors_1.UsageError(`${flag} entries must match <id> or <ws>:<id>: ${value}`);
+    }
+    return normalized;
+}
+function normalizeLowercaseList(raw) {
+    return parseCsvList(raw).map((value) => value.toLowerCase());
+}
+function normalizeIdList(raw, flag) {
+    return parseCsvList(raw).map((value) => normalizeId(value, flag));
+}
+function normalizeIdRefList(raw, flag) {
+    return parseCsvList(raw).map((value) => normalizeIdRef(value, flag));
+}
+function normalizeSkillList(raw) {
+    return parseCsvList(raw).map((value) => {
+        const normalized = value.toLowerCase();
+        if (!SKILL_SLUG_RE.test(normalized)) {
+            throw new errors_1.UsageError(`--add-skills entries must be kebab-case: ${value}`);
+        }
+        return normalized;
+    });
+}
+function appendUnique(existing, additions) {
+    const next = [...existing];
+    const seen = new Set(existing);
+    for (const value of additions) {
+        if (!seen.has(value)) {
+            next.push(value);
+            seen.add(value);
+        }
+    }
+    return next;
+}
+function toStringList(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item));
+    }
+    return [];
+}
+function maybeReindex(root, config) {
+    if (!config.index.auto_reindex) {
+        return;
+    }
+    const outputPath = path_1.default.resolve(root, config.index.global_index_path);
+    (0, index_cache_1.writeIndex)(outputPath, (0, indexer_1.buildIndex)(root, config, { tolerant: config.index.tolerant }));
+}
+function loadMutableTaskNode(root, idOrQid, wsHint) {
+    const config = (0, config_1.loadConfig)(root);
+    const { index } = (0, index_cache_1.loadIndex)({ root, config });
+    const resolved = (0, qid_1.resolveQid)(index, idOrQid, normalizeWorkspace(wsHint));
+    if (resolved.status !== "ok") {
+        throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("task", idOrQid, resolved, normalizeWorkspace(wsHint)));
+    }
+    const node = index.nodes[resolved.qid];
+    if (!node) {
+        throw new errors_1.NotFoundError(`task not found: ${idOrQid}`);
+    }
+    if (!MUTABLE_TASK_TYPES.has(node.type)) {
+        throw new errors_1.UsageError(`mdkg task only supports task, bug, and test nodes; use markdown editing for ${node.type}:${node.id}`);
+    }
+    const filePath = path_1.default.resolve(root, node.path);
+    const content = fs_1.default.readFileSync(filePath, "utf8");
+    const parsed = (0, frontmatter_1.parseFrontmatter)(content, filePath);
+    return {
+        config,
+        index,
+        qid: node.qid,
+        ws: node.ws,
+        id: node.id,
+        type: node.type,
+        filePath,
+        frontmatter: { ...parsed.frontmatter },
+        body: parsed.body,
+    };
+}
+function writeNodeFile(root, filePath, frontmatter, body) {
+    const lines = (0, frontmatter_1.formatFrontmatter)(frontmatter, frontmatter_1.DEFAULT_FRONTMATTER_KEY_ORDER);
+    const frontmatterBlock = ["---", ...lines, "---"].join("\n");
+    const content = body.length > 0 ? `${frontmatterBlock}\n${body}` : frontmatterBlock;
+    fs_1.default.writeFileSync(filePath, content, "utf8");
+}
+function ensureStatusAllowed(config, statusRaw, flag = "--status") {
+    const normalized = statusRaw.trim().toLowerCase();
+    const allowed = new Set(config.work.status_enum.map((value) => value.toLowerCase()));
+    if (!allowed.has(normalized)) {
+        throw new errors_1.UsageError(`${flag} must be one of ${Array.from(allowed).join(", ")}`);
+    }
+    return normalized;
+}
+function ensurePriorityAllowed(config, priority) {
+    if (!Number.isInteger(priority) ||
+        priority < config.work.priority_min ||
+        priority > config.work.priority_max) {
+        throw new errors_1.UsageError(`--priority must be between ${config.work.priority_min} and ${config.work.priority_max}`);
+    }
+    return priority;
+}
+function ensureNodeRefsExist(index, values, ws, label) {
+    for (const value of values) {
+        const resolved = (0, qid_1.resolveQid)(index, value, ws);
+        if (resolved.status !== "ok") {
+            throw new errors_1.NotFoundError((0, qid_1.formatResolveError)(label, value, resolved, ws));
+        }
+    }
+}
+function ensureSkillsExist(root, node, slugs) {
+    if (slugs.length === 0) {
+        return;
+    }
+    const skillsIndex = (0, skills_indexer_1.buildSkillsIndex)(root, node.config);
+    for (const slug of slugs) {
+        if (!skillsIndex.skills[slug]) {
+            throw new errors_1.NotFoundError(`skill not found: ${slug}`);
+        }
+    }
+}
+function updateUpdatedDate(frontmatter, now) {
+    frontmatter.updated = (0, date_1.formatDate)(now);
+}
+function runTaskStartCommand(options) {
+    const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
+    const now = options.now ?? new Date();
+    loaded.frontmatter.status = ensureStatusAllowed(loaded.config, "progress");
+    updateUpdatedDate(loaded.frontmatter, now);
+    writeNodeFile(options.root, loaded.filePath, loaded.frontmatter, loaded.body);
+    maybeReindex(options.root, loaded.config);
+    (0, event_support_1.appendAutomaticEvent)({
+        root: options.root,
+        ws: loaded.ws,
+        kind: "TASK_STARTED",
+        status: "ok",
+        refs: [loaded.id],
+        notes: options.note ?? `status set to progress via mdkg task start`,
+        runId: options.runId,
+        now,
+    });
+    console.log(`task started: ${loaded.qid}`);
+}
+function runTaskUpdateCommand(options) {
+    const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
+    const now = options.now ?? new Date();
+    if (options.status) {
+        loaded.frontmatter.status = ensureStatusAllowed(loaded.config, options.status);
+    }
+    if (options.priority !== undefined) {
+        loaded.frontmatter.priority = String(ensurePriorityAllowed(loaded.config, options.priority));
+    }
+    const nextLinks = appendUnique(toStringList(loaded.frontmatter.links), parseCsvList(options.addLinks));
+    const nextArtifacts = appendUnique(toStringList(loaded.frontmatter.artifacts), parseCsvList(options.addArtifacts));
+    const nextRefs = appendUnique(toStringList(loaded.frontmatter.refs), normalizeIdList(options.addRefs, "--add-refs"));
+    const nextTags = appendUnique(toStringList(loaded.frontmatter.tags), normalizeLowercaseList(options.addTags));
+    const nextSkills = appendUnique(toStringList(loaded.frontmatter.skills), normalizeSkillList(options.addSkills));
+    const blockedByAdditions = normalizeIdRefList(options.addBlockedBy, "--add-blocked-by");
+    ensureNodeRefsExist(loaded.index, blockedByAdditions, loaded.ws, "blocked_by");
+    const nextBlockedBy = options.clearBlockedBy
+        ? blockedByAdditions
+        : appendUnique(toStringList(loaded.frontmatter.blocked_by), blockedByAdditions);
+    ensureSkillsExist(options.root, loaded, nextSkills);
+    loaded.frontmatter.links = nextLinks;
+    loaded.frontmatter.artifacts = nextArtifacts;
+    loaded.frontmatter.refs = nextRefs;
+    loaded.frontmatter.tags = nextTags;
+    loaded.frontmatter.skills = nextSkills;
+    loaded.frontmatter.blocked_by = nextBlockedBy;
+    updateUpdatedDate(loaded.frontmatter, now);
+    writeNodeFile(options.root, loaded.filePath, loaded.frontmatter, loaded.body);
+    maybeReindex(options.root, loaded.config);
+    (0, event_support_1.appendAutomaticEvent)({
+        root: options.root,
+        ws: loaded.ws,
+        kind: "TASK_UPDATED",
+        status: "ok",
+        refs: [loaded.id],
+        artifacts: nextArtifacts,
+        notes: options.note ?? `task metadata updated via mdkg task update`,
+        runId: options.runId,
+        now,
+    });
+    console.log(`task updated: ${loaded.qid}`);
+}
+function runTaskDoneCommand(options) {
+    const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
+    const now = options.now ?? new Date();
+    const nextLinks = appendUnique(toStringList(loaded.frontmatter.links), parseCsvList(options.addLinks));
+    const nextArtifacts = appendUnique(toStringList(loaded.frontmatter.artifacts), parseCsvList(options.addArtifacts));
+    const nextRefs = appendUnique(toStringList(loaded.frontmatter.refs), normalizeIdList(options.addRefs, "--add-refs"));
+    loaded.frontmatter.status = ensureStatusAllowed(loaded.config, "done");
+    loaded.frontmatter.links = nextLinks;
+    loaded.frontmatter.artifacts = nextArtifacts;
+    loaded.frontmatter.refs = nextRefs;
+    updateUpdatedDate(loaded.frontmatter, now);
+    writeNodeFile(options.root, loaded.filePath, loaded.frontmatter, loaded.body);
+    (0, event_support_1.appendAutomaticEvent)({
+        root: options.root,
+        ws: loaded.ws,
+        kind: "TASK_DONE",
+        status: "ok",
+        refs: [loaded.id],
+        artifacts: nextArtifacts,
+        notes: options.note ?? `status set to done via mdkg task done`,
+        runId: options.runId,
+        now,
+    });
+    if (options.checkpoint) {
+        (0, checkpoint_1.runCheckpointNewCommand)({
+            root: options.root,
+            title: options.checkpoint,
+            ws: loaded.ws,
+            relates: loaded.id,
+            scope: loaded.id,
+            runId: options.runId,
+            note: `checkpoint created from mdkg task done for ${loaded.id}`,
+            now,
+        });
+    }
+    maybeReindex(options.root, loaded.config);
+    console.log(`task done: ${loaded.qid}`);
+}

package/dist/commands/validate.js

@@ -9,6 +9,7 @@ const path_1 = __importDefault(require("path"));
 const config_1 = require("../core/config");
 const template_schema_1 = require("../graph/template_schema");
 const node_1 = require("../graph/node");
+const skills_indexer_1 = require("../graph/skills_indexer");
 const workspace_files_1 = require("../graph/workspace_files");
 const validate_graph_1 = require("../graph/validate_graph");
 const errors_1 = require("../util/errors");
@@ -116,6 +117,7 @@ function buildIndexNode(root, ws, filePath, node) {
         artifacts: node.artifacts,
         refs: node.refs,
         aliases: node.aliases,
+        skills: node.skills,
         path: path_1.default.relative(root, filePath),
         edges: normalizeEdges(node.edges, ws),
     };
@@ -128,6 +130,65 @@ function buildWorkspaceMap(config) {
     }
     return workspaces;
 }
+function listDirectories(dirPath) {
+    if (!fs_1.default.existsSync(dirPath)) {
+        return [];
+    }
+    return fs_1.default
+        .readdirSync(dirPath, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path_1.default.join(dirPath, entry.name))
+        .sort();
+}
+function validateEventsJsonl(root, config, errors) {
+    for (const [alias, workspace] of Object.entries(config.workspaces)) {
+        if (!workspace.enabled) {
+            continue;
+        }
+        const eventsPath = path_1.default.resolve(root, workspace.path, workspace.mdkg_dir, "work", "events", "events.jsonl");
+        if (!fs_1.default.existsSync(eventsPath)) {
+            continue;
+        }
+        const lines = fs_1.default.readFileSync(eventsPath, "utf8").split(/\r?\n/);
+        for (let i = 0; i < lines.length; i += 1) {
+            const raw = lines[i].trim();
+            if (!raw) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                errors.push(`${eventsPath}:${i + 1}: invalid JSON`);
+                continue;
+            }
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                errors.push(`${eventsPath}:${i + 1}: event must be a JSON object`);
+                continue;
+            }
+            const event = parsed;
+            for (const key of ["ts", "run_id", "workspace", "agent", "kind", "status"]) {
+                const value = event[key];
+                if (typeof value !== "string" || value.trim().length === 0) {
+                    errors.push(`${eventsPath}:${i + 1}: ${key} is required and must be a non-empty string`);
+                }
+            }
+            if (!Array.isArray(event.refs)) {
+                errors.push(`${eventsPath}:${i + 1}: refs is required and must be a list`);
+            }
+            if (!Array.isArray(event.artifacts)) {
+                errors.push(`${eventsPath}:${i + 1}: artifacts is required and must be a list`);
+            }
+            if (typeof event.notes !== "string") {
+                errors.push(`${eventsPath}:${i + 1}: notes is required and must be a string`);
+            }
+            if (typeof event.workspace === "string" && event.workspace !== alias) {
+                errors.push(`${eventsPath}:${i + 1}: workspace must match ${alias}`);
+            }
+        }
+    }
+}
 function runValidateCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const templateSchemas = (0, template_schema_1.loadTemplateSchemas)(options.root, config, node_1.ALLOWED_TYPES);
@@ -196,9 +257,45 @@ function runValidateCommand(options) {
     };
     const graphErrors = (0, validate_graph_1.collectGraphErrors)(index, { allowMissing: false });
     errors.push(...graphErrors);
+    try {
+        const skillsIndex = (0, skills_indexer_1.buildSkillsIndex)(options.root, config);
+        const knownSkills = new Set(Object.keys(skillsIndex.skills));
+        for (const node of Object.values(nodes)) {
+            for (const slug of node.skills) {
+                if (!knownSkills.has(slug)) {
+                    errors.push(`${node.qid}: skills reference missing slug: ${slug}`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "unknown skill validation error";
+        errors.push(message);
+    }
+    const skillsRoot = (0, skills_indexer_1.resolveSkillsRoot)(options.root, config);
+    for (const dirPath of listDirectories(skillsRoot)) {
+        const canonicalPath = path_1.default.join(dirPath, "SKILL.md");
+        const compatPath = path_1.default.join(dirPath, "SKILLS.md");
+        const hasCanonical = fs_1.default.existsSync(canonicalPath);
+        const hasCompat = fs_1.default.existsSync(compatPath);
+        if (hasCanonical && hasCompat) {
+            errors.push(`${dirPath}: both SKILL.md and SKILLS.md exist`);
+            continue;
+        }
+        if (!hasCanonical && !hasCompat) {
+            errors.push(`${dirPath}: missing SKILL.md or SKILLS.md`);
+            continue;
+        }
+        if (hasCompat) {
+            warnings.push(`${path_1.default.relative(options.root, compatPath)}: using legacy SKILLS.md compatibility file`);
+        }
+    }
+    validateEventsJsonl(options.root, config, errors);
+    const uniqueWarnings = Array.from(new Set(warnings));
+    const uniqueErrors = Array.from(new Set(errors));
     const reportLines = [
-        ...warnings.map((warning) => `warning: ${warning}`),
-        ...errors,
+        ...uniqueWarnings.map((warning) => `warning: ${warning}`),
+        ...uniqueErrors,
     ];
     let outPath = undefined;
     if (options.out) {
@@ -207,20 +304,20 @@ function runValidateCommand(options) {
         fs_1.default.writeFileSync(outPath, reportLines.join("\n"), "utf8");
     }
     if (!options.quiet) {
-        for (const warning of warnings) {
+        for (const warning of uniqueWarnings) {
             console.error(`warning: ${warning}`);
         }
     }
-    if (errors.length > 0) {
+    if (uniqueErrors.length > 0) {
         if (outPath) {
-            console.error(`validation failed: ${errors.length} error(s). details written to ${outPath}`);
+            console.error(`validation failed: ${uniqueErrors.length} error(s). details written to ${outPath}`);
         }
         else {
-            for (const error of errors) {
+            for (const error of uniqueErrors) {
                 console.error(error);
             }
         }
-        throw new errors_1.ValidationError(`validation failed with ${errors.length} error(s)`);
+        throw new errors_1.ValidationError(`validation failed with ${uniqueErrors.length} error(s)`);
     }
     if (outPath) {
         console.log(`validation report written: ${outPath}`);

package/dist/graph/edges.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractEdges = extractEdges;
-const ID_REF_RE = /^([a-z][a-z0-9_]*:)?[a-z]+-[0-9]+$/;
+const id_1 = require("../util/id");
 function formatError(filePath, key, message) {
     return new Error(`${filePath}: ${key} ${message}`);
 }
@@ -10,7 +10,7 @@ function normalizeIdRef(value, filePath, key) {
     if (normalized !== value) {
         throw formatError(filePath, key, "must be lowercase");
     }
-    if (!ID_REF_RE.test(normalized)) {
+    if (!(0, id_1.isCanonicalIdRef)(normalized)) {
         throw formatError(filePath, key, `invalid id reference: ${value}`);
     }
     return normalized;

package/dist/graph/frontmatter.js

@@ -24,6 +24,7 @@ exports.DEFAULT_FRONTMATTER_KEY_ORDER = [
     "blocks",
     "refs",
     "aliases",
+    "skills",
     "cases",
     "scope",
     "created",

package/dist/graph/indexer.js

@@ -81,6 +81,7 @@ function buildIndex(root, config, options = {}) {
                     artifacts: node.artifacts,
                     refs: node.refs,
                     aliases: node.aliases,
+                    skills: node.skills,
                     path: relPath,
                     edges: normalizedEdges,
                 };
@@ -140,5 +141,25 @@ function buildIndex(root, config, options = {}) {
         reverse_edges,
     };
     (0, validate_graph_1.validateGraph)(index, { allowMissing: tolerant });
+    const latestCheckpointByWorkspace = {};
+    for (const alias of workspaceAliases) {
+        const candidates = Object.values(nodes)
+            .filter((node) => node.ws === alias && 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);
+        });
+        if (candidates.length > 0) {
+            latestCheckpointByWorkspace[alias] = candidates[0].qid;
+        }
+    }
+    if (Object.keys(latestCheckpointByWorkspace).length > 0) {
+        index.meta.latest_checkpoint_qid = latestCheckpointByWorkspace;
+    }
     return index;
 }

package/dist/graph/node.js

@@ -4,7 +4,7 @@ exports.ALLOWED_TYPES = exports.DEC_TYPES = exports.WORK_TYPES = void 0;
 exports.parseNode = parseNode;
 const frontmatter_1 = require("./frontmatter");
 const edges_1 = require("./edges");
-const ID_RE = /^[a-z]+-[0-9]+$/;
+const id_1 = require("../util/id");
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 const DEC_ID_RE = /^dec-[0-9]+$/;
 exports.WORK_TYPES = new Set(["epic", "feat", "task", "bug", "checkpoint", "test"]);
@@ -23,6 +23,7 @@ exports.ALLOWED_TYPES = new Set([
     "test",
 ]);
 const DEC_STATUS = new Set(["proposed", "accepted", "rejected", "superseded"]);
+const SKILL_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function formatError(filePath, message) {
     return new Error(`${filePath}: ${message}`);
 }
@@ -74,11 +75,11 @@ function requireLowercaseList(values, key, filePath) {
     });
 }
 function isValidId(value) {
-    return ID_RE.test(value) || value === "rule-guide";
+    return (0, id_1.isCanonicalId)(value);
 }
 function requireIdFormat(value, key, filePath) {
     if (!isValidId(value)) {
-        throw formatError(filePath, `${key} must match <prefix>-<number>`);
+        throw formatError(filePath, `${key} must match <prefix>-<number> or reserved id`);
     }
     return value;
 }
@@ -104,11 +105,20 @@ function normalizeIdList(values, key, filePath) {
             throw formatError(filePath, `${key} entries must be lowercase`);
         }
         if (!isValidId(value)) {
-            throw formatError(filePath, `${key} entries must match <prefix>-<number>`);
+            throw formatError(filePath, `${key} entries must match <prefix>-<number> or reserved id`);
         }
         return value;
     });
 }
+function normalizeSkillList(values, filePath) {
+    return values.map((value, index) => {
+        const normalized = value.toLowerCase();
+        if (!SKILL_SLUG_RE.test(normalized)) {
+            throw formatError(filePath, `skills[${index}] must be kebab-case`);
+        }
+        return normalized;
+    });
+}
 function requireTemplateSchema(type, templateSchemas, filePath) {
     const schema = templateSchemas[type];
     if (!schema) {
@@ -192,6 +202,11 @@ function parseNode(content, filePath, options) {
     const artifacts = optionalList(frontmatter, "artifacts", filePath);
     const refs = normalizeIdList(optionalList(frontmatter, "refs", filePath), "refs", filePath);
     const aliases = requireLowercaseList(optionalList(frontmatter, "aliases", filePath), "aliases", filePath);
+    const skillsRaw = optionalList(frontmatter, "skills", filePath);
+    const skills = normalizeSkillList(skillsRaw, filePath);
+    if (skills.length > 0 && !exports.WORK_TYPES.has(type)) {
+        throw formatError(filePath, "skills is only allowed for work items");
+    }
     normalizeIdList(optionalList(frontmatter, "scope", filePath), "scope", filePath);
     const supersedesValue = optionalString(frontmatter, "supersedes", filePath);
     if (supersedesValue !== undefined) {
@@ -218,6 +233,7 @@ function parseNode(content, filePath, options) {
         artifacts,
         refs,
         aliases,
+        skills,
         edges,
         body,
         frontmatter,

package/dist/graph/skills_index_cache.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeSkillsIndex = writeSkillsIndex;
+exports.loadSkillsIndex = loadSkillsIndex;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../core/paths");
+const skills_indexer_1 = require("./skills_indexer");
+function mtimeMs(filePath) {
+    return fs_1.default.statSync(filePath).mtimeMs;
+}
+function listFilesAndDirectories(dir) {
+    if (!fs_1.default.existsSync(dir)) {
+        return [];
+    }
+    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    const items = [dir];
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            items.push(...listFilesAndDirectories(fullPath));
+            continue;
+        }
+        if (entry.isFile()) {
+            items.push(fullPath);
+        }
+    }
+    return items;
+}
+function isSkillsIndexStale(root, config) {
+    const indexPath = (0, skills_indexer_1.resolveSkillsIndexPath)(root);
+    if (!fs_1.default.existsSync(indexPath)) {
+        return true;
+    }
+    const indexMtime = mtimeMs(indexPath);
+    const cfgPath = (0, paths_1.configPath)(root);
+    if (fs_1.default.existsSync(cfgPath) && mtimeMs(cfgPath) > indexMtime) {
+        return true;
+    }
+    const skillsRoot = (0, skills_indexer_1.resolveSkillsRoot)(root, config);
+    for (const item of listFilesAndDirectories(skillsRoot)) {
+        if (mtimeMs(item) > indexMtime) {
+            return true;
+        }
+    }
+    return false;
+}
+function readSkillsIndex(indexPath) {
+    try {
+        const raw = fs_1.default.readFileSync(indexPath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "unknown error";
+        throw new Error(`failed to read skills index: ${message}`);
+    }
+}
+function writeSkillsIndex(indexPath, index) {
+    const sortedSkills = {};
+    for (const slug of Object.keys(index.skills).sort()) {
+        sortedSkills[slug] = index.skills[slug];
+    }
+    const sortedIndex = {
+        ...index,
+        skills: sortedSkills,
+    };
+    fs_1.default.mkdirSync(path_1.default.dirname(indexPath), { recursive: true });
+    fs_1.default.writeFileSync(indexPath, JSON.stringify(sortedIndex, null, 2), "utf8");
+}
+function loadSkillsIndex(options) {
+    const useCache = options.useCache ?? true;
+    const allowReindex = options.allowReindex ?? options.config.index.auto_reindex;
+    const indexPath = (0, skills_indexer_1.resolveSkillsIndexPath)(options.root);
+    if (!useCache) {
+        const index = (0, skills_indexer_1.buildSkillsIndex)(options.root, options.config);
+        return { index, rebuilt: true, stale: false };
+    }
+    const stale = isSkillsIndexStale(options.root, options.config);
+    if (fs_1.default.existsSync(indexPath) && !stale) {
+        return { index: readSkillsIndex(indexPath), rebuilt: false, stale: false };
+    }
+    if (allowReindex) {
+        const index = (0, skills_indexer_1.buildSkillsIndex)(options.root, options.config);
+        writeSkillsIndex(indexPath, index);
+        return { index, rebuilt: true, stale };
+    }
+    if (fs_1.default.existsSync(indexPath)) {
+        return { index: readSkillsIndex(indexPath), rebuilt: false, stale: true };
+    }
+    throw new Error("skills index missing and auto-reindex is disabled");
+}