mdkg 0.3.0 → 0.3.2

package/dist/commands/format.js

@@ -17,6 +17,8 @@ const errors_1 = require("../util/errors");
 const date_1 = require("../util/date");
 const id_1 = require("../util/id");
 const refs_1 = require("../util/refs");
+const atomic_1 = require("../util/atomic");
+const lock_1 = require("../util/lock");
 const DEC_ID_RE = /^dec-[0-9]+$/;
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 const ID_LIST_KEYS = new Set(["refs", "scope"]);
@@ -248,7 +250,7 @@ function normalizeFrontmatter(frontmatter, schema, type, workStatusEnum, priorit
     }
     return { normalized, errors };
 }
-function runFormatCommand(options) {
+function runFormatCommandLocked(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const templateSchemas = (0, template_schema_1.loadTemplateSchemas)(options.root, config, node_1.ALLOWED_TYPES);
     const filesByAlias = (0, workspace_files_1.listWorkspaceDocFilesByAlias)(options.root, config);
@@ -324,7 +326,11 @@ function runFormatCommand(options) {
         throw new errors_1.ValidationError(`format failed with ${errors.length} error(s)`);
     }
     for (const update of updates) {
-        fs_1.default.writeFileSync(update.filePath, update.content, "utf8");
+        (0, atomic_1.atomicWriteFile)(update.filePath, update.content);
     }
     console.log(`format updated ${updates.length} file(s)`);
 }
+function runFormatCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => runFormatCommandLocked(options));
+}

package/dist/commands/goal.js

@@ -29,7 +29,7 @@ const qid_1 = require("../util/qid");
 const sort_1 = require("../util/sort");
 const event_support_1 = require("./event_support");
 const node_card_1 = require("./node_card");
-const CONCRETE_GOAL_NEXT_TYPES = new Set(["feat", "task", "bug", "test"]);
+const CONCRETE_GOAL_NEXT_TYPES = new Set(["feat", "task", "bug", "test", "spike"]);
 const SELECTED_GOAL_STATE_PATH = path_1.default.join(".mdkg", "state", "selected-goal.json");
 const GOAL_STATE_BY_ACTION = {
     pause: "paused",

package/dist/commands/next.js

@@ -7,8 +7,8 @@ const errors_1 = require("../util/errors");
 const qid_1 = require("../util/qid");
 const sort_1 = require("../util/sort");
 const node_card_1 = require("./node_card");
-const NEXT_TYPES = new Set(["feat", "task", "bug", "test"]);
-const NO_MATCH_MESSAGE = 'no matching work items found; consider `mdkg new task "..."` or `mdkg new test "..."`';
+const NEXT_TYPES = new Set(["feat", "task", "bug", "test", "spike"]);
+const NO_MATCH_MESSAGE = 'no matching work items found; consider `mdkg new task "..."`, `mdkg new test "..."`, or `mdkg new spike "..."`';
 function normalizeWorkspace(value) {
     if (!value || value === "all") {
         return undefined;

package/dist/commands/skill.js

@@ -20,6 +20,8 @@ const skill_support_1 = require("./skill_support");
 const query_output_1 = require("./query_output");
 const event_support_1 = require("./event_support");
 const skill_mirror_1 = require("./skill_mirror");
+const atomic_1 = require("../util/atomic");
+const lock_1 = require("../util/lock");
 function parseCsvList(raw) {
     if (!raw) {
         return [];
@@ -142,7 +144,7 @@ function matchesSkillQuery(skill, terms) {
     }
     return true;
 }
-function runSkillNewCommand(options) {
+function runSkillNewCommandLocked(options) {
     const root = options.root;
     const config = (0, config_1.loadConfig)(root);
     const slug = normalizeSlug(options.slug);
@@ -181,7 +183,7 @@ function runSkillNewCommand(options) {
         authors,
         links,
     });
-    fs_1.default.writeFileSync(canonicalPath, content, "utf8");
+    (0, atomic_1.atomicWriteFile)(canonicalPath, content);
     (0, skill_support_1.ensureSkillsRegistry)(root, config);
     (0, skill_support_1.refreshSkillsRegistry)(root, config);
     if ((0, skill_mirror_1.shouldMaintainSkillMirrors)(root)) {
@@ -220,6 +222,10 @@ function runSkillNewCommand(options) {
     }
     console.log(`skill created: ${receipt.qid} (${receipt.path})`);
 }
+function runSkillNewCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => runSkillNewCommandLocked(options));
+}
 function runSkillListCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const { index, rebuilt, stale } = (0, skills_index_cache_1.loadSkillsIndex)({
@@ -426,7 +432,7 @@ function runSkillValidateCommand(options) {
     }
     console.log(`skill validation ok: ${checkedCount} skill${checkedCount === 1 ? "" : "s"} checked`);
 }
-function runSkillSyncCommand(options) {
+function runSkillSyncCommandLocked(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const result = (0, skill_mirror_1.syncSkillMirrors)({
         root: options.root,
@@ -443,3 +449,7 @@ function runSkillSyncCommand(options) {
     }
     console.log(`skill mirror sync ok: ${result.synced} synced, ${result.pruned} pruned across ${result.targets} target${result.targets === 1 ? "" : "s"}`);
 }
+function runSkillSyncCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => runSkillSyncCommandLocked(options));
+}

package/dist/commands/skill_support.js

@@ -14,6 +14,7 @@ exports.formatSkillCard = formatSkillCard;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const skills_indexer_1 = require("../graph/skills_indexer");
+const atomic_1 = require("../util/atomic");
 exports.SKILL_REGISTRY_START = "<!-- mdkg:skill-registry:start -->";
 exports.SKILL_REGISTRY_END = "<!-- mdkg:skill-registry:end -->";
 function renderYamlList(values) {
@@ -105,8 +106,7 @@ function ensureSkillsRegistry(root, config) {
     const skillsRoot = (0, skills_indexer_1.resolveSkillsRoot)(root, config);
     const registryPath = path_1.default.join(skillsRoot, "registry.md");
     if (!fs_1.default.existsSync(registryPath)) {
-        fs_1.default.mkdirSync(path_1.default.dirname(registryPath), { recursive: true });
-        fs_1.default.writeFileSync(registryPath, registryTemplate(), "utf8");
+        (0, atomic_1.atomicWriteFile)(registryPath, registryTemplate());
     }
     return registryPath;
 }
@@ -115,7 +115,7 @@ function refreshSkillsRegistry(root, config) {
     const raw = fs_1.default.readFileSync(registryPath, "utf8");
     const index = (0, skills_indexer_1.buildSkillsIndex)(root, config);
     const updated = replaceManagedSection(raw, renderRegistryLines(index));
-    fs_1.default.writeFileSync(registryPath, updated, "utf8");
+    (0, atomic_1.atomicWriteFile)(registryPath, updated);
 }
 function formatSkillCard(skill) {
     return [skill.qid, "skill", "-/-", skill.name, skill.path].join(" | ");

package/dist/commands/status.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.collectStatus = collectStatus;
+exports.runStatusCommand = runStatusCommand;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../core/config");
+const project_db_migrations_1 = require("../core/project_db_migrations");
+const version_1 = require("../core/version");
+const capabilities_indexer_1 = require("../graph/capabilities_indexer");
+const capabilities_index_cache_1 = require("../graph/capabilities_index_cache");
+const index_cache_1 = require("../graph/index_cache");
+const skills_indexer_1 = require("../graph/skills_indexer");
+const skills_index_cache_1 = require("../graph/skills_index_cache");
+const staleness_1 = require("../graph/staleness");
+const subgraphs_1 = require("../graph/subgraphs");
+const validate_graph_1 = require("../graph/validate_graph");
+function rel(root, target) {
+    return path_1.default.relative(root, target).replace(/\\/g, "/") || ".";
+}
+function runGit(root, args) {
+    const result = (0, child_process_1.spawnSync)("git", args, { cwd: root, encoding: "utf8" });
+    if (result.status !== 0) {
+        return undefined;
+    }
+    return result.stdout.trim();
+}
+function gitStatus(root) {
+    const inside = runGit(root, ["rev-parse", "--is-inside-work-tree"]) === "true";
+    if (!inside) {
+        return {
+            inside: false,
+            branch: null,
+            dirty: false,
+            dirty_count: 0,
+            untracked_count: 0,
+            ahead: null,
+            behind: null,
+        };
+    }
+    const branch = runGit(root, ["rev-parse", "--abbrev-ref", "HEAD"]) ?? null;
+    const porcelain = runGit(root, ["status", "--porcelain"]) ?? "";
+    const lines = porcelain.split(/\r?\n/).filter(Boolean);
+    const untracked = lines.filter((line) => line.startsWith("??")).length;
+    const aheadBehindRaw = runGit(root, ["rev-list", "--left-right", "--count", "HEAD...@{upstream}"]);
+    const [aheadRaw, behindRaw] = aheadBehindRaw ? aheadBehindRaw.split(/\s+/) : [];
+    return {
+        inside: true,
+        branch,
+        dirty: lines.length > 0,
+        dirty_count: lines.length,
+        untracked_count: untracked,
+        ahead: aheadRaw === undefined ? null : Number.parseInt(aheadRaw, 10),
+        behind: behindRaw === undefined ? null : Number.parseInt(behindRaw, 10),
+    };
+}
+function cacheStatus(root, filePath, stale) {
+    let staleValue = null;
+    try {
+        staleValue = stale();
+    }
+    catch {
+        staleValue = null;
+    }
+    return {
+        path: rel(root, filePath),
+        exists: fs_1.default.existsSync(filePath),
+        stale: staleValue,
+    };
+}
+function readSelectedGoalState(root) {
+    const filePath = path_1.default.join(root, ".mdkg", "state", "selected-goal.json");
+    if (!fs_1.default.existsSync(filePath)) {
+        return { state: null };
+    }
+    try {
+        const parsed = JSON.parse(fs_1.default.readFileSync(filePath, "utf8"));
+        if (typeof parsed.qid === "string" &&
+            typeof parsed.id === "string" &&
+            typeof parsed.ws === "string" &&
+            typeof parsed.selected_at === "string") {
+            return {
+                state: {
+                    qid: parsed.qid.toLowerCase(),
+                    id: parsed.id.toLowerCase(),
+                    ws: parsed.ws.toLowerCase(),
+                    selected_at: parsed.selected_at,
+                },
+            };
+        }
+        return { state: null, warning: "selected goal state is malformed" };
+    }
+    catch {
+        return { state: null, warning: "selected goal state is unreadable" };
+    }
+}
+function releaseStatus(root) {
+    const version = (0, version_1.readPackageVersion)();
+    const changelogPath = path_1.default.join(root, "CHANGELOG.md");
+    const changelogHasVersion = fs_1.default.existsSync(changelogPath)
+        ? fs_1.default.readFileSync(changelogPath, "utf8").includes(`## ${version}`) ||
+            fs_1.default.readFileSync(changelogPath, "utf8").includes(`## [${version}]`)
+        : false;
+    return {
+        package_version: version,
+        changelog_path: fs_1.default.existsSync(changelogPath) ? "CHANGELOG.md" : null,
+        changelog_has_version: changelogHasVersion,
+    };
+}
+function collectStatus(root) {
+    const warnings = [];
+    const errors = [];
+    const config = (0, config_1.loadConfig)(root);
+    let index;
+    let graphStale = false;
+    let graphWarnings = [];
+    let graphErrors = [];
+    try {
+        const loaded = (0, index_cache_1.loadIndex)({
+            root,
+            config,
+            useCache: true,
+            allowReindex: false,
+            includeImports: true,
+        });
+        index = loaded.index;
+        graphStale = loaded.stale;
+        graphWarnings = loaded.warnings;
+        graphErrors = (0, validate_graph_1.collectGraphErrors)(loaded.index);
+    }
+    catch (err) {
+        graphStale = true;
+        graphErrors = [err instanceof Error ? err.message : String(err)];
+    }
+    const selected = readSelectedGoalState(root);
+    if (selected.warning) {
+        warnings.push(selected.warning);
+    }
+    const selectedNode = selected.state && index ? index.nodes[selected.state.qid] : undefined;
+    const selectedAchieved = selectedNode?.status === "done" || String(selectedNode?.attributes.goal_state ?? "") === "achieved";
+    const selectedMissing = selected.state !== null && !selectedNode;
+    if (selectedMissing) {
+        warnings.push("selected goal is missing from the graph index");
+    }
+    if (selectedAchieved) {
+        warnings.push("selected goal is already achieved");
+    }
+    const git = gitStatus(root);
+    if (git.inside && git.dirty) {
+        warnings.push(`git worktree is dirty (${git.dirty_count} changed paths)`);
+    }
+    const generated = {
+        index: cacheStatus(root, path_1.default.resolve(root, config.index.global_index_path), () => (0, staleness_1.isIndexStale)(root, config)),
+        skills: cacheStatus(root, (0, skills_indexer_1.resolveSkillsIndexPath)(root), () => (0, skills_index_cache_1.isSkillsIndexStale)(root, config)),
+        capabilities: cacheStatus(root, (0, capabilities_indexer_1.resolveCapabilitiesIndexPath)(root, config), () => (0, capabilities_index_cache_1.isCapabilitiesIndexStale)(root, config)),
+        subgraphs: cacheStatus(root, (0, subgraphs_1.resolveSubgraphsIndexPath)(root), () => (0, subgraphs_1.isSubgraphsIndexStale)(root, config)),
+    };
+    let db = {
+        enabled: false,
+        ok: null,
+        database: null,
+        failure_count: 0,
+        warning_count: 0,
+    };
+    if (config.db.enabled) {
+        const verification = (0, project_db_migrations_1.verifyProjectDb)(root, config);
+        db = {
+            enabled: verification.enabled,
+            ok: verification.ok,
+            database: verification.database,
+            failure_count: verification.failure_count,
+            warning_count: verification.warning_count,
+        };
+    }
+    if (graphErrors.length > 0) {
+        errors.push(...graphErrors.map((error) => `graph: ${error}`));
+    }
+    if (db.enabled && db.ok === false) {
+        errors.push("db: project DB verification failed");
+    }
+    if (graphStale) {
+        warnings.push("graph index cache is stale");
+    }
+    warnings.push(...graphWarnings.map((warning) => `graph: ${warning}`));
+    const cacheEntries = [
+        ["index", generated.index, true],
+        ["skills", generated.skills, true],
+        ["capabilities", generated.capabilities, true],
+        ["subgraphs", generated.subgraphs, Object.keys(config.subgraphs).length > 0],
+    ];
+    for (const [name, cache, required] of cacheEntries) {
+        if (!required) {
+            continue;
+        }
+        if (!cache.exists) {
+            warnings.push(`${name} cache is missing`);
+        }
+        else if (cache.stale) {
+            warnings.push(`${name} cache is stale`);
+        }
+    }
+    const level = errors.length > 0 ? "fail" : warnings.length > 0 ? "warn" : "ok";
+    return {
+        action: "status",
+        ok: errors.length === 0,
+        level,
+        root,
+        mdkg: {
+            version: (0, version_1.readPackageVersion)(),
+            config_schema_version: config.schema_version,
+            index_backend: config.index.backend,
+        },
+        git,
+        release: releaseStatus(root),
+        graph: {
+            ok: graphErrors.length === 0,
+            node_count: index ? Object.keys(index.nodes).length : null,
+            workspace_count: index ? Object.keys(index.workspaces).length : null,
+            stale: graphStale,
+            warning_count: graphWarnings.length,
+            error_count: graphErrors.length,
+        },
+        goal: {
+            selected: selected.state,
+            selected_exists: selected.state === null ? null : !selectedMissing,
+            selected_achieved: selected.state === null ? null : selectedAchieved,
+            active_node: selectedNode?.attributes.active_node ?? null,
+            goal_state: selectedNode?.attributes.goal_state ?? null,
+            status: selectedNode?.status ?? null,
+        },
+        db,
+        generated,
+        summary: {
+            level,
+            warning_count: warnings.length,
+            error_count: errors.length,
+            warnings,
+            errors,
+        },
+    };
+}
+function runStatusCommand(options) {
+    const payload = collectStatus(options.root);
+    if (options.json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(`status ${payload.level}`);
+    console.log(`root: ${payload.root}`);
+    console.log(`mdkg: ${payload.mdkg.version}`);
+    console.log(`git: ${payload.git.inside ? `${payload.git.branch ?? "detached"} dirty=${payload.git.dirty}` : "not a git repo"}`);
+    console.log(`graph: ${payload.graph.ok ? "ok" : "fail"} nodes=${payload.graph.node_count ?? "unknown"} stale=${payload.graph.stale}`);
+    console.log(`db: ${payload.db.enabled ? (payload.db.ok ? "ok" : "fail") : "disabled"}`);
+    if (payload.goal.selected) {
+        console.log(`goal: ${payload.goal.selected.qid} status=${payload.goal.status ?? "unknown"} state=${payload.goal.goal_state ?? "unknown"}`);
+    }
+    else {
+        console.log("goal: none selected");
+    }
+    for (const warning of payload.summary.warnings) {
+        console.log(`warn: ${warning}`);
+    }
+    for (const error of payload.summary.errors) {
+        console.log(`fail: ${error}`);
+    }
+}