mdkg 0.1.0 → 0.1.2

package/dist/graph/bundle_imports.js

@@ -0,0 +1,418 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBundleImportsIndexPath = resolveBundleImportsIndexPath;
+exports.buildBundleImportsIndex = buildBundleImportsIndex;
+exports.writeBundleImportsIndex = writeBundleImportsIndex;
+exports.isBundleImportsIndexStale = isBundleImportsIndexStale;
+exports.mergeBundleImportsIntoIndex = mergeBundleImportsIntoIndex;
+exports.importWarnings = importWarnings;
+exports.buildImportedCapabilityRecords = buildImportedCapabilityRecords;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const paths_1 = require("../core/paths");
+const zip_1 = require("../util/zip");
+const IMPORTS_CACHE_VERSION = 1;
+const MANIFEST_ENTRY = "manifest.json";
+const GLOBAL_INDEX_ENTRY = ".mdkg/index/global.json";
+const SKILLS_INDEX_ENTRY = ".mdkg/index/skills.json";
+const CAPABILITIES_INDEX_ENTRY = ".mdkg/index/capabilities.json";
+function toPosixPath(value) {
+    return value.split(path_1.default.sep).join("/");
+}
+function sha256Buffer(buffer) {
+    return `sha256:${crypto_1.default.createHash("sha256").update(buffer).digest("hex")}`;
+}
+function readJsonEntry(entries, entryPath) {
+    const data = entries.get(entryPath);
+    if (!data) {
+        throw new Error(`missing bundle entry: ${entryPath}`);
+    }
+    return JSON.parse(data.toString("utf8"));
+}
+function readBundleEntries(bundlePath) {
+    return new Map((0, zip_1.readZipEntries)(fs_1.default.readFileSync(bundlePath)).map((entry) => [entry.name, entry.data]));
+}
+function resolveBundlePath(root, entry) {
+    return path_1.default.resolve(root, entry.path);
+}
+function gitOutput(cwd, args) {
+    const result = (0, child_process_1.spawnSync)("git", args, { cwd, encoding: "utf8", stdio: "pipe" });
+    if (result.status !== 0) {
+        return null;
+    }
+    const output = result.stdout.trim();
+    return output.length > 0 ? output : null;
+}
+function sourcePathState(root, entry, manifest, warnings, errors) {
+    if (!entry.source_path) {
+        return false;
+    }
+    const sourceRoot = path_1.default.resolve(root, entry.source_path);
+    if (!fs_1.default.existsSync(sourceRoot)) {
+        errors.push(`source_path does not exist: ${entry.source_path}`);
+        return false;
+    }
+    const currentHead = gitOutput(sourceRoot, ["rev-parse", "HEAD"]);
+    const currentStatus = gitOutput(sourceRoot, ["status", "--porcelain"]);
+    let stale = false;
+    if (manifest.source?.git_head && currentHead && manifest.source.git_head !== currentHead) {
+        warnings.push(`source HEAD changed: ${manifest.source.git_head} -> ${currentHead}`);
+        stale = true;
+    }
+    if (currentStatus) {
+        warnings.push(`source_path has uncommitted changes: ${entry.source_path}`);
+        stale = true;
+    }
+    return stale;
+}
+function ageState(bundlePath, entry, warnings) {
+    if (entry.max_stale_seconds === undefined) {
+        return false;
+    }
+    const ageSeconds = Math.floor((Date.now() - fs_1.default.statSync(bundlePath).mtimeMs) / 1000);
+    if (ageSeconds <= entry.max_stale_seconds) {
+        return false;
+    }
+    warnings.push(`bundle age ${ageSeconds}s exceeds max_stale_seconds ${entry.max_stale_seconds}`);
+    return true;
+}
+function remapTarget(target, qidMap) {
+    if (!target) {
+        return undefined;
+    }
+    return qidMap.get(target) ?? target;
+}
+function remapTargets(targets, qidMap) {
+    return targets.map((target) => qidMap.get(target) ?? target);
+}
+function addReverseEdge(reverse, edgeKey, target, source) {
+    if (!target) {
+        return;
+    }
+    reverse[edgeKey] = reverse[edgeKey] ?? {};
+    reverse[edgeKey][target] = reverse[edgeKey][target] ?? [];
+    reverse[edgeKey][target].push(source);
+}
+function addReverseEdges(reverse, node) {
+    addReverseEdge(reverse, "epic", node.edges.epic, node.qid);
+    addReverseEdge(reverse, "parent", node.edges.parent, node.qid);
+    addReverseEdge(reverse, "prev", node.edges.prev, node.qid);
+    addReverseEdge(reverse, "next", node.edges.next, node.qid);
+    for (const target of node.edges.relates) {
+        addReverseEdge(reverse, "relates", target, node.qid);
+    }
+    for (const target of node.edges.blocked_by) {
+        addReverseEdge(reverse, "blocked_by", target, node.qid);
+    }
+    for (const target of node.edges.blocks) {
+        addReverseEdge(reverse, "blocks", target, node.qid);
+    }
+}
+function entryHashErrors(entries, manifest) {
+    const errors = [];
+    for (const file of manifest.files ?? []) {
+        const data = entries.get(file.path);
+        if (!data) {
+            errors.push(`missing bundle entry: ${file.path}`);
+            continue;
+        }
+        if (sha256Buffer(data) !== file.sha256) {
+            errors.push(`hash mismatch for ${file.path}`);
+        }
+        if (data.length !== file.size) {
+            errors.push(`size mismatch for ${file.path}`);
+        }
+    }
+    return errors;
+}
+function projectOneImport(root, alias, entry) {
+    const bundlePath = resolveBundlePath(root, entry);
+    const relativeBundlePath = toPosixPath(path_1.default.relative(root, bundlePath));
+    const warnings = [];
+    const errors = [];
+    const nodes = {};
+    const reverse_edges = {};
+    let manifest;
+    let sourceIndex;
+    let stale = false;
+    if (!entry.enabled) {
+        return {
+            health: {
+                alias,
+                path: entry.path,
+                enabled: false,
+                visibility: entry.visibility,
+                expected_profile: entry.expected_profile,
+                stale: false,
+                warning_count: 0,
+                error_count: 0,
+                warnings: [],
+                errors: [],
+            },
+            nodes,
+            reverse_edges,
+        };
+    }
+    try {
+        if (!fs_1.default.existsSync(bundlePath)) {
+            throw new Error(`bundle not found: ${entry.path}`);
+        }
+        const entries = readBundleEntries(bundlePath);
+        manifest = readJsonEntry(entries, MANIFEST_ENTRY);
+        sourceIndex = readJsonEntry(entries, GLOBAL_INDEX_ENTRY);
+        readJsonEntry(entries, SKILLS_INDEX_ENTRY);
+        readJsonEntry(entries, CAPABILITIES_INDEX_ENTRY);
+        errors.push(...entryHashErrors(entries, manifest));
+        if (manifest.profile !== entry.expected_profile) {
+            errors.push(`expected ${entry.expected_profile} bundle but found ${manifest.profile}`);
+        }
+        stale = sourcePathState(root, entry, manifest, warnings, errors) || stale;
+        stale = ageState(bundlePath, entry, warnings) || stale;
+        const idOwners = new Map();
+        for (const node of Object.values(sourceIndex.nodes)) {
+            const owners = idOwners.get(node.id) ?? [];
+            owners.push(node.qid);
+            idOwners.set(node.id, owners);
+        }
+        for (const [id, owners] of idOwners.entries()) {
+            if (owners.length > 1) {
+                errors.push(`duplicate projected id ${id} from ${owners.join(", ")}; create per-workspace bundles or use portable unique ids`);
+            }
+        }
+        if (errors.length === 0) {
+            const qidMap = new Map();
+            for (const node of Object.values(sourceIndex.nodes)) {
+                qidMap.set(node.qid, `${alias}:${node.id}`);
+            }
+            for (const node of Object.values(sourceIndex.nodes)) {
+                const projectedQid = qidMap.get(node.qid);
+                const projected = {
+                    ...node,
+                    ws: alias,
+                    qid: projectedQid,
+                    path: `${relativeBundlePath}#${toPosixPath(node.path)}`,
+                    attributes: { ...(node.attributes ?? {}) },
+                    edges: {
+                        epic: remapTarget(node.edges.epic, qidMap),
+                        parent: remapTarget(node.edges.parent, qidMap),
+                        prev: remapTarget(node.edges.prev, qidMap),
+                        next: remapTarget(node.edges.next, qidMap),
+                        relates: remapTargets(node.edges.relates, qidMap),
+                        blocked_by: remapTargets(node.edges.blocked_by, qidMap),
+                        blocks: remapTargets(node.edges.blocks, qidMap),
+                    },
+                    source: {
+                        imported: true,
+                        read_only: true,
+                        import_alias: alias,
+                        original_qid: node.qid,
+                        original_ws: node.ws,
+                        original_path: toPosixPath(node.path),
+                        bundle_path: relativeBundlePath,
+                        bundle_hash: manifest.bundle_hash,
+                        profile: manifest.profile,
+                        visibility: entry.visibility,
+                        stale,
+                        warnings: [...warnings],
+                        source_repo: entry.source_repo ?? manifest.source?.repo,
+                        source_git_head: manifest.source?.git_head ?? null,
+                    },
+                };
+                nodes[projected.qid] = projected;
+                addReverseEdges(reverse_edges, projected);
+            }
+        }
+    }
+    catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+    }
+    return {
+        health: {
+            alias,
+            path: entry.path,
+            enabled: entry.enabled,
+            visibility: entry.visibility,
+            expected_profile: entry.expected_profile,
+            profile: manifest?.profile,
+            bundle_hash: manifest?.bundle_hash,
+            source_git_head: manifest?.source?.git_head ?? null,
+            source_repo: entry.source_repo ?? manifest?.source?.repo,
+            stale,
+            warning_count: warnings.length,
+            error_count: errors.length,
+            warnings,
+            errors,
+        },
+        nodes,
+        reverse_edges,
+    };
+}
+function resolveBundleImportsIndexPath(root) {
+    return path_1.default.resolve(root, ".mdkg", "index", "imports.json");
+}
+function buildBundleImportsIndex(root, config) {
+    const imports = [];
+    const nodes = {};
+    const reverse_edges = {};
+    const workspaces = {};
+    for (const alias of Object.keys(config.bundle_imports).sort()) {
+        const entry = config.bundle_imports[alias];
+        const projected = projectOneImport(root, alias, entry);
+        imports.push(projected.health);
+        if (!entry.enabled || projected.health.error_count > 0) {
+            continue;
+        }
+        workspaces[alias] = { path: `bundle:${entry.path}`, enabled: true };
+        Object.assign(nodes, projected.nodes);
+        for (const [edgeKey, targets] of Object.entries(projected.reverse_edges)) {
+            reverse_edges[edgeKey] = reverse_edges[edgeKey] ?? {};
+            for (const [target, sources] of Object.entries(targets)) {
+                reverse_edges[edgeKey][target] = [
+                    ...(reverse_edges[edgeKey][target] ?? []),
+                    ...sources,
+                ].sort();
+            }
+        }
+    }
+    return {
+        index: {
+            meta: {
+                tool: config.tool,
+                schema_version: config.schema_version,
+                cache_version: IMPORTS_CACHE_VERSION,
+                generated_at: new Date().toISOString(),
+                root,
+                import_count: imports.length,
+                node_count: Object.keys(nodes).length,
+            },
+            imports,
+            nodes,
+            reverse_edges,
+        },
+        workspaces,
+    };
+}
+function writeBundleImportsIndex(indexPath, index) {
+    fs_1.default.mkdirSync(path_1.default.dirname(indexPath), { recursive: true });
+    fs_1.default.writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf8");
+}
+function isBundleImportsIndexStale(root, config) {
+    const indexPath = resolveBundleImportsIndexPath(root);
+    if (!fs_1.default.existsSync(indexPath)) {
+        return Object.keys(config.bundle_imports).length > 0;
+    }
+    const indexMtime = fs_1.default.statSync(indexPath).mtimeMs;
+    const cfgPath = (0, paths_1.configPath)(root);
+    if (fs_1.default.existsSync(cfgPath) && fs_1.default.statSync(cfgPath).mtimeMs > indexMtime) {
+        return true;
+    }
+    for (const entry of Object.values(config.bundle_imports)) {
+        const bundlePath = path_1.default.resolve(root, entry.path);
+        if (!fs_1.default.existsSync(bundlePath)) {
+            return true;
+        }
+        if (fs_1.default.statSync(bundlePath).mtimeMs > indexMtime) {
+            return true;
+        }
+    }
+    return false;
+}
+function mergeBundleImportsIntoIndex(base, projection) {
+    const nodes = { ...base.nodes, ...projection.index.nodes };
+    const reverse_edges = JSON.parse(JSON.stringify(base.reverse_edges));
+    for (const [edgeKey, targets] of Object.entries(projection.index.reverse_edges)) {
+        reverse_edges[edgeKey] = reverse_edges[edgeKey] ?? {};
+        for (const [target, sources] of Object.entries(targets)) {
+            reverse_edges[edgeKey][target] = [
+                ...(reverse_edges[edgeKey][target] ?? []),
+                ...sources,
+            ].sort();
+        }
+    }
+    return {
+        ...base,
+        meta: {
+            ...base.meta,
+            workspaces: Array.from(new Set([...base.meta.workspaces, ...Object.keys(projection.workspaces)])).sort(),
+        },
+        workspaces: {
+            ...base.workspaces,
+            ...projection.workspaces,
+        },
+        nodes,
+        reverse_edges,
+    };
+}
+function importWarnings(projection) {
+    const warnings = [];
+    for (const item of projection.index.imports) {
+        for (const warning of item.warnings) {
+            warnings.push(`bundle import ${item.alias}: ${warning}`);
+        }
+        for (const error of item.errors) {
+            warnings.push(`bundle import ${item.alias}: ${error}`);
+        }
+    }
+    return warnings;
+}
+function buildImportedCapabilityRecords(root, config) {
+    const records = [];
+    const warnings = [];
+    for (const alias of Object.keys(config.bundle_imports).sort()) {
+        const entry = config.bundle_imports[alias];
+        if (!entry.enabled) {
+            continue;
+        }
+        const projection = projectOneImport(root, alias, entry);
+        for (const warning of projection.health.warnings) {
+            warnings.push(`bundle import ${alias}: ${warning}`);
+        }
+        for (const error of projection.health.errors) {
+            warnings.push(`bundle import ${alias}: ${error}`);
+        }
+        if (projection.health.error_count > 0) {
+            continue;
+        }
+        try {
+            const bundlePath = resolveBundlePath(root, entry);
+            const relativeBundlePath = toPosixPath(path_1.default.relative(root, bundlePath));
+            const entries = readBundleEntries(bundlePath);
+            const capabilities = readJsonEntry(entries, CAPABILITIES_INDEX_ENTRY);
+            for (const record of capabilities.records ?? []) {
+                const id = String(record.id ?? "");
+                const originalQid = String(record.qid ?? id);
+                const originalWorkspace = String(record.workspace ?? "");
+                const originalPath = String(record.path ?? "");
+                records.push({
+                    ...record,
+                    workspace: alias,
+                    visibility: entry.visibility,
+                    qid: `${alias}:${id}`,
+                    path: `${relativeBundlePath}#${originalPath}`,
+                    source: {
+                        imported: true,
+                        read_only: true,
+                        import_alias: alias,
+                        original_qid: originalQid,
+                        original_workspace: originalWorkspace,
+                        original_path: originalPath,
+                        bundle_path: relativeBundlePath,
+                        bundle_hash: projection.health.bundle_hash,
+                        profile: projection.health.profile,
+                        stale: projection.health.stale,
+                        warnings: [...projection.health.warnings],
+                    },
+                });
+            }
+        }
+        catch (err) {
+            warnings.push(`bundle import ${alias}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return { records, warnings };
+}

package/dist/graph/capabilities_index_cache.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCapabilitiesIndexStale = isCapabilitiesIndexStale;
+exports.writeCapabilitiesIndex = writeCapabilitiesIndex;
+exports.loadCapabilitiesIndex = loadCapabilitiesIndex;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../core/paths");
+const workspace_files_1 = require("./workspace_files");
+const capabilities_indexer_1 = require("./capabilities_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 workspaceSkillsRoots(root, config) {
+    return Object.keys(config.workspaces)
+        .sort()
+        .filter((alias) => config.workspaces[alias].enabled)
+        .map((alias) => {
+        const workspace = config.workspaces[alias];
+        return path_1.default.resolve(root, workspace.path, workspace.mdkg_dir, "skills");
+    });
+}
+function isCapabilitiesIndexStale(root, config) {
+    const indexPath = (0, capabilities_indexer_1.resolveCapabilitiesIndexPath)(root, config);
+    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;
+    }
+    for (const filePath of (0, workspace_files_1.listWorkspaceDocFiles)(root, config)) {
+        if (mtimeMs(filePath) > indexMtime) {
+            return true;
+        }
+    }
+    for (const skillsRoot of workspaceSkillsRoots(root, config)) {
+        for (const item of listFilesAndDirectories(skillsRoot)) {
+            if (mtimeMs(item) > indexMtime) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function readCapabilitiesIndex(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 capabilities index: ${message}`);
+    }
+}
+function writeCapabilitiesIndex(indexPath, index) {
+    fs_1.default.mkdirSync(path_1.default.dirname(indexPath), { recursive: true });
+    fs_1.default.writeFileSync(indexPath, JSON.stringify(index, null, 2), "utf8");
+}
+function loadCapabilitiesIndex(options) {
+    const useCache = options.useCache ?? true;
+    const allowReindex = options.allowReindex ?? options.config.index.auto_reindex;
+    const indexPath = (0, capabilities_indexer_1.resolveCapabilitiesIndexPath)(options.root, options.config);
+    if (!useCache) {
+        const index = (0, capabilities_indexer_1.buildCapabilitiesIndex)(options.root, options.config);
+        return { index, rebuilt: true, stale: false };
+    }
+    const stale = isCapabilitiesIndexStale(options.root, options.config);
+    if (fs_1.default.existsSync(indexPath) && !stale) {
+        return { index: readCapabilitiesIndex(indexPath), rebuilt: false, stale: false };
+    }
+    if (allowReindex) {
+        const index = (0, capabilities_indexer_1.buildCapabilitiesIndex)(options.root, options.config);
+        writeCapabilitiesIndex(indexPath, index);
+        return { index, rebuilt: true, stale };
+    }
+    if (fs_1.default.existsSync(indexPath)) {
+        return { index: readCapabilitiesIndex(indexPath), rebuilt: false, stale: true };
+    }
+    throw new Error("capabilities index missing and auto-reindex is disabled");
+}