mdkg 0.1.1 → 0.1.3

package/dist/commands/bundle_import.js

@@ -0,0 +1,255 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBundleImportAddCommand = runBundleImportAddCommand;
+exports.runBundleImportListCommand = runBundleImportListCommand;
+exports.runBundleImportRemoveCommand = runBundleImportRemoveCommand;
+exports.runBundleImportEnableCommand = runBundleImportEnableCommand;
+exports.runBundleImportDisableCommand = runBundleImportDisableCommand;
+exports.runBundleImportVerifyCommand = runBundleImportVerifyCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../core/config");
+const migrate_1 = require("../core/migrate");
+const workspace_path_1 = require("../core/workspace_path");
+const bundle_imports_1 = require("../graph/bundle_imports");
+const errors_1 = require("../util/errors");
+const atomic_1 = require("../util/atomic");
+const lock_1 = require("../util/lock");
+const ALIAS_RE = /^[a-z][a-z0-9_]*$/;
+function writeJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function normalizeAlias(alias) {
+    if (alias === "all") {
+        throw new errors_1.UsageError("bundle import alias cannot be 'all'");
+    }
+    if (alias !== alias.toLowerCase() || !ALIAS_RE.test(alias)) {
+        throw new errors_1.UsageError("bundle import alias must be lowercase and use [a-z0-9_]");
+    }
+    return alias;
+}
+function normalizeVisibility(value) {
+    const normalized = (value ?? "private").toLowerCase();
+    if (normalized === "private" || normalized === "internal" || normalized === "public") {
+        return normalized;
+    }
+    throw new errors_1.UsageError("--visibility must be private, internal, or public");
+}
+function normalizeProfile(value) {
+    const normalized = (value ?? "private").toLowerCase();
+    if (normalized === "private" || normalized === "public") {
+        return normalized;
+    }
+    throw new errors_1.UsageError("--profile must be private or public");
+}
+function normalizeContained(value, label) {
+    try {
+        return (0, workspace_path_1.normalizeContainedWorkspacePath)(value, label);
+    }
+    catch (err) {
+        throw new errors_1.UsageError(err instanceof Error ? err.message : String(err));
+    }
+}
+function readRawConfig(root) {
+    const configPath = path_1.default.join(root, ".mdkg", "config.json");
+    if (!fs_1.default.existsSync(configPath)) {
+        throw new errors_1.NotFoundError(`config not found at ${configPath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs_1.default.readFileSync(configPath, "utf8"));
+    }
+    catch (err) {
+        throw new errors_1.UsageError(`failed to read config: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const migrated = (0, migrate_1.migrateConfig)(parsed).config;
+    (0, config_1.validateConfigSchema)(migrated);
+    if (typeof migrated !== "object" || migrated === null || Array.isArray(migrated)) {
+        throw new errors_1.UsageError("config must be a JSON object");
+    }
+    return { configPath, raw: migrated };
+}
+function writeRawConfig(configPath, raw) {
+    (0, atomic_1.atomicWriteFile)(configPath, `${JSON.stringify(raw, null, 2)}\n`);
+}
+function getImports(raw) {
+    const imports = raw.bundle_imports;
+    if (imports === undefined) {
+        raw.bundle_imports = {};
+        return raw.bundle_imports;
+    }
+    if (typeof imports !== "object" || imports === null || Array.isArray(imports)) {
+        throw new errors_1.UsageError("config.bundle_imports must be an object");
+    }
+    return imports;
+}
+function receiptForHealth(action, health) {
+    return {
+        action,
+        import: health,
+    };
+}
+function healthByAlias(root, alias) {
+    const config = (0, config_1.loadConfig)(root);
+    const health = (0, bundle_imports_1.buildBundleImportsIndex)(root, config).index.imports.find((item) => item.alias === alias);
+    if (!health) {
+        throw new errors_1.NotFoundError(`bundle import not found: ${alias}`);
+    }
+    return health;
+}
+function withBundleImportLock(root, fn) {
+    const config = (0, config_1.loadConfig)(root);
+    return (0, lock_1.withMutationLock)(root, config.index.lock_timeout_ms, fn);
+}
+function runBundleImportAddCommandLocked(options) {
+    const alias = normalizeAlias(options.alias);
+    const bundlePath = normalizeContained(options.bundlePath, "bundle import path");
+    const visibility = normalizeVisibility(options.visibility);
+    const expected_profile = normalizeProfile(options.profile);
+    if (visibility !== "private" && expected_profile !== "public") {
+        throw new errors_1.UsageError("--profile public is required when --visibility is public or internal");
+    }
+    const source_path = options.sourcePath
+        ? normalizeContained(options.sourcePath, "bundle import source path")
+        : undefined;
+    if (options.maxStaleSeconds !== undefined && (!Number.isInteger(options.maxStaleSeconds) || options.maxStaleSeconds <= 0)) {
+        throw new errors_1.UsageError("--max-stale-seconds must be a positive integer");
+    }
+    const { configPath, raw } = readRawConfig(options.root);
+    const imports = getImports(raw);
+    if (imports[alias]) {
+        throw new errors_1.UsageError(`bundle import already exists: ${alias}`);
+    }
+    const workspaces = raw.workspaces;
+    if (workspaces && workspaces[alias]) {
+        throw new errors_1.UsageError(`bundle import alias collides with workspace: ${alias}`);
+    }
+    imports[alias] = {
+        path: bundlePath,
+        enabled: true,
+        visibility,
+        expected_profile,
+        ...(source_path ? { source_path } : {}),
+        ...(options.sourceRepo ? { source_repo: options.sourceRepo } : {}),
+        ...(options.maxStaleSeconds !== undefined ? { max_stale_seconds: options.maxStaleSeconds } : {}),
+    };
+    raw.bundle_imports = imports;
+    const validated = (0, config_1.validateConfigSchema)(raw);
+    const health = (0, bundle_imports_1.buildBundleImportsIndex)(options.root, validated).index.imports.find((item) => item.alias === alias);
+    if (!health) {
+        throw new errors_1.NotFoundError(`bundle import not found after validation: ${alias}`);
+    }
+    if (health.error_count > 0) {
+        throw new errors_1.ValidationError(`bundle import ${alias} is invalid:\n${health.errors.join("\n")}`);
+    }
+    writeRawConfig(configPath, raw);
+    const receipt = receiptForHealth("added", health);
+    if (options.json) {
+        writeJson(receipt);
+        return;
+    }
+    console.log(`bundle import added: ${alias} (${bundlePath})`);
+    if (health.warning_count > 0) {
+        console.log(`warnings: ${health.warning_count}`);
+    }
+}
+function runBundleImportAddCommand(options) {
+    return withBundleImportLock(options.root, () => runBundleImportAddCommandLocked(options));
+}
+function runBundleImportListCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const imports = (0, bundle_imports_1.buildBundleImportsIndex)(options.root, config).index.imports;
+    if (options.json) {
+        writeJson({ action: "list", count: imports.length, imports });
+        return;
+    }
+    if (imports.length === 0) {
+        console.log("no bundle imports configured");
+        return;
+    }
+    for (const item of imports) {
+        const status = item.enabled ? item.error_count > 0 ? "invalid" : item.stale ? "stale" : "ok" : "disabled";
+        console.log(`${item.alias} | ${status} | ${item.visibility} | ${item.path}`);
+    }
+}
+function runBundleImportRemoveCommandLocked(options) {
+    const alias = normalizeAlias(options.alias);
+    const { configPath, raw } = readRawConfig(options.root);
+    const imports = getImports(raw);
+    const existing = imports[alias];
+    if (!existing) {
+        throw new errors_1.NotFoundError(`bundle import not found: ${alias}`);
+    }
+    delete imports[alias];
+    raw.bundle_imports = imports;
+    (0, config_1.validateConfigSchema)(raw);
+    writeRawConfig(configPath, raw);
+    const receipt = { action: "removed", import: { alias } };
+    if (options.json) {
+        writeJson(receipt);
+        return;
+    }
+    console.log(`bundle import removed: ${alias}`);
+}
+function runBundleImportRemoveCommand(options) {
+    return withBundleImportLock(options.root, () => runBundleImportRemoveCommandLocked(options));
+}
+function setBundleImportEnabledLocked(options, enabled) {
+    const alias = normalizeAlias(options.alias);
+    const { configPath, raw } = readRawConfig(options.root);
+    const imports = getImports(raw);
+    const existing = imports[alias];
+    if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+        throw new errors_1.NotFoundError(`bundle import not found: ${alias}`);
+    }
+    imports[alias] = { ...existing, enabled };
+    raw.bundle_imports = imports;
+    (0, config_1.validateConfigSchema)(raw);
+    writeRawConfig(configPath, raw);
+    const health = healthByAlias(options.root, alias);
+    const receipt = receiptForHealth(enabled ? "enabled" : "disabled", health);
+    if (options.json) {
+        writeJson(receipt);
+        return;
+    }
+    console.log(`bundle import ${enabled ? "enabled" : "disabled"}: ${alias}`);
+}
+function runBundleImportEnableCommand(options) {
+    withBundleImportLock(options.root, () => setBundleImportEnabledLocked(options, true));
+}
+function runBundleImportDisableCommand(options) {
+    withBundleImportLock(options.root, () => setBundleImportEnabledLocked(options, false));
+}
+function runBundleImportVerifyCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const all = options.all || !options.alias;
+    const imports = (0, bundle_imports_1.buildBundleImportsIndex)(options.root, config).index.imports.filter((item) => all ? true : item.alias === options.alias);
+    if (!all && imports.length === 0) {
+        throw new errors_1.NotFoundError(`bundle import not found: ${options.alias}`);
+    }
+    const ok = imports.every((item) => item.error_count === 0 && !item.stale);
+    const receipt = { action: "verified", ok, count: imports.length, imports };
+    if (options.json) {
+        writeJson(receipt);
+    }
+    else if (ok) {
+        console.log(`bundle imports verified: ${imports.length}`);
+    }
+    else {
+        console.log(`bundle import verify failed: ${imports.length}`);
+        for (const item of imports) {
+            for (const warning of item.warnings) {
+                console.log(`warning: ${item.alias}: ${warning}`);
+            }
+            for (const error of item.errors) {
+                console.log(`error: ${item.alias}: ${error}`);
+            }
+        }
+    }
+    if (!ok) {
+        throw new errors_1.ValidationError("bundle import verify failed");
+    }
+}

package/dist/commands/capability.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCapabilityListCommand = runCapabilityListCommand;
+exports.runCapabilitySearchCommand = runCapabilitySearchCommand;
+exports.runCapabilityShowCommand = runCapabilityShowCommand;
+const config_1 = require("../core/config");
+const capabilities_indexer_1 = require("../graph/capabilities_indexer");
+const capabilities_index_cache_1 = require("../graph/capabilities_index_cache");
+const bundle_imports_1 = require("../graph/bundle_imports");
+const errors_1 = require("../util/errors");
+function normalizeKind(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = value.toLowerCase();
+    if (capabilities_indexer_1.CAPABILITY_KINDS.includes(normalized)) {
+        return normalized;
+    }
+    throw new errors_1.UsageError(`--kind must be one of ${capabilities_indexer_1.CAPABILITY_KINDS.join(", ")}`);
+}
+function normalizeVisibility(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = value.toLowerCase();
+    if (capabilities_indexer_1.CAPABILITY_VISIBILITIES.includes(normalized)) {
+        return normalized;
+    }
+    throw new errors_1.UsageError(`--visibility must be one of ${capabilities_indexer_1.CAPABILITY_VISIBILITIES.join(", ")}`);
+}
+function loadRecords(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const { index, stale, rebuilt } = (0, capabilities_index_cache_1.loadCapabilitiesIndex)({
+        root: options.root,
+        config,
+        useCache: !options.noCache,
+        allowReindex: !options.noReindex,
+    });
+    if (stale && !rebuilt && !options.noCache) {
+        console.error("warning: capabilities index is stale; run mdkg index to refresh");
+    }
+    const imported = (0, bundle_imports_1.buildImportedCapabilityRecords)(options.root, config);
+    for (const warning of imported.warnings) {
+        console.error(`warning: ${warning}`);
+    }
+    return [...index.records, ...imported.records];
+}
+function applyFilters(records, options) {
+    const kind = normalizeKind(options.kind);
+    const visibility = normalizeVisibility(options.visibility);
+    return records.filter((record) => {
+        if (kind && record.kind !== kind) {
+            return false;
+        }
+        if (visibility && record.visibility !== visibility) {
+            return false;
+        }
+        return true;
+    });
+}
+function capabilitySearchText(record) {
+    return [
+        record.kind,
+        record.workspace,
+        record.visibility,
+        record.id,
+        record.qid,
+        record.slug,
+        record.name,
+        record.title,
+        record.description,
+        record.path,
+        ...record.tags,
+        ...record.refs,
+        ...record.aliases,
+        ...record.links,
+        ...record.headings.map((heading) => heading.text),
+        JSON.stringify(record.spec ?? {}),
+        JSON.stringify(record.work ?? {}),
+        JSON.stringify(record.skill ?? {}),
+    ]
+        .filter((value) => typeof value === "string" && value.length > 0)
+        .join(" ")
+        .toLowerCase();
+}
+function matchesQuery(record, query) {
+    const terms = query
+        .toLowerCase()
+        .split(/\s+/)
+        .map((term) => term.trim())
+        .filter(Boolean);
+    if (terms.length === 0) {
+        return true;
+    }
+    const text = capabilitySearchText(record);
+    return terms.every((term) => text.includes(term));
+}
+function printCapabilityList(records, json, query) {
+    if (json) {
+        console.log(JSON.stringify({
+            kind: "capability",
+            query,
+            count: records.length,
+            items: records,
+        }, null, 2));
+        return;
+    }
+    if (records.length === 0) {
+        console.log(query ? `no capabilities matched query "${query}"` : "no capabilities matched current filters");
+        return;
+    }
+    console.log(`capabilities: ${records.length}`);
+    for (const record of records) {
+        const label = record.slug ?? record.id;
+        console.log(`${record.qid} | ${record.kind} | ${record.visibility} | ${label} | ${record.title}`);
+    }
+}
+function resolveCapability(records, id) {
+    const normalized = id.toLowerCase();
+    const exact = records.find((record) => record.qid === id || record.id === id);
+    if (exact) {
+        return exact;
+    }
+    const matches = records.filter((record) => record.slug === normalized ||
+        record.id === normalized ||
+        record.qid.toLowerCase() === normalized ||
+        `skill:${record.slug}` === normalized);
+    if (matches.length === 1) {
+        return matches[0];
+    }
+    if (matches.length > 1) {
+        throw new errors_1.UsageError(`capability reference is ambiguous: ${id}`);
+    }
+    throw new errors_1.NotFoundError(`capability not found: ${id}`);
+}
+function printCapability(record, json) {
+    if (json) {
+        console.log(JSON.stringify({ kind: "capability", item: record }, null, 2));
+        return;
+    }
+    console.log(`${record.qid} | ${record.kind} | ${record.visibility}`);
+    console.log(`title: ${record.title}`);
+    if (record.description) {
+        console.log(`description: ${record.description}`);
+    }
+    if (record.tags.length > 0) {
+        console.log(`tags: ${record.tags.join(", ")}`);
+    }
+    console.log(`path: ${record.path}`);
+}
+function runCapabilityListCommand(options) {
+    const records = applyFilters(loadRecords(options), options);
+    printCapabilityList(records, options.json);
+}
+function runCapabilitySearchCommand(options) {
+    const records = applyFilters(loadRecords(options), options).filter((record) => matchesQuery(record, options.query));
+    printCapabilityList(records, options.json, options.query);
+}
+function runCapabilityShowCommand(options) {
+    const records = loadRecords(options);
+    printCapability(resolveCapability(records, options.id), options.json);
+}

package/dist/commands/checkpoint.js

@@ -13,6 +13,9 @@ const loader_1 = require("../templates/loader");
 const date_1 = require("../util/date");
 const errors_1 = require("../util/errors");
 const id_1 = require("../util/id");
+const atomic_1 = require("../util/atomic");
+const lock_1 = require("../util/lock");
+const sqlite_index_1 = require("../graph/sqlite_index");
 const event_support_1 = require("./event_support");
 function parseCsvList(raw) {
     if (!raw) {
@@ -38,6 +41,9 @@ function normalizeIdRef(value, key) {
     return normalized;
 }
 function nextCheckpointId(index, ws) {
+    return `chk-${maxCheckpointId(index, ws) + 1}`;
+}
+function maxCheckpointId(index, ws) {
     let max = 0;
     for (const node of Object.values(index.nodes)) {
         if (node.ws !== ws) {
@@ -52,7 +58,7 @@ function nextCheckpointId(index, ws) {
             max = parsed;
         }
     }
-    return `chk-${max + 1}`;
+    return max;
 }
 function slugifyTitle(title) {
     const slug = title
@@ -77,7 +83,7 @@ function normalizeWorkspace(value) {
     }
     return normalized;
 }
-function createCheckpoint(options) {
+function createCheckpointLocked(options) {
     const title = options.title.trim();
     if (!title) {
         throw new errors_1.UsageError("checkpoint title cannot be empty");
@@ -99,7 +105,15 @@ function createCheckpoint(options) {
         throw new errors_1.UsageError(`--priority must be between ${priorityMin} and ${priorityMax}`);
     }
     const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
-    const id = nextCheckpointId(index, ws);
+    const id = (0, sqlite_index_1.isSqliteBackend)(config)
+        ? (0, sqlite_index_1.reserveSqliteNumericId)({
+            root: options.root,
+            config,
+            ws,
+            prefix: "chk",
+            currentMax: maxCheckpointId(index, ws),
+        }) ?? nextCheckpointId(index, ws)
+        : nextCheckpointId(index, ws);
     const slug = slugifyTitle(title);
     const fileName = `${id}-${slug}.md`;
     const wsEntry = config.workspaces[ws];
@@ -129,8 +143,16 @@ function createCheckpoint(options) {
         relates,
         scope,
     });
-    fs_1.default.mkdirSync(workDir, { recursive: true });
-    fs_1.default.writeFileSync(filePath, content, "utf8");
+    try {
+        (0, atomic_1.writeFileExclusive)(filePath, content);
+    }
+    catch (err) {
+        const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : "";
+        if (code === "EEXIST") {
+            throw new errors_1.UsageError(`checkpoint file already exists: ${path_1.default.relative(options.root, filePath)}`);
+        }
+        throw err;
+    }
     (0, event_support_1.appendAutomaticEvent)({
         root: options.root,
         ws,
@@ -148,6 +170,10 @@ function createCheckpoint(options) {
         path: path_1.default.relative(options.root, filePath),
     };
 }
+function createCheckpoint(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    return (0, lock_1.withMutationLock)(options.root, config.index.lock_timeout_ms, () => createCheckpointLocked(options));
+}
 function runCheckpointNewCommand(options) {
     const checkpoint = createCheckpoint(options);
     if (options.json) {