mdkg 0.1.3 → 0.1.5

package/dist/commands/capability.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCapabilityListCommand = runCapabilityListCommand;
 exports.runCapabilitySearchCommand = runCapabilitySearchCommand;
 exports.runCapabilityShowCommand = runCapabilityShowCommand;
+exports.runCapabilityResolveCommand = runCapabilityResolveCommand;
 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 subgraphs_1 = require("../graph/subgraphs");
 const errors_1 = require("../util/errors");
 function normalizeKind(value) {
     if (value === undefined) {
@@ -39,11 +40,11 @@ function loadRecords(options) {
     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) {
+    const subgraph = (0, subgraphs_1.buildSubgraphCapabilityRecords)(options.root, config);
+    for (const warning of subgraph.warnings) {
         console.error(`warning: ${warning}`);
     }
-    return [...index.records, ...imported.records];
+    return [...index.records, ...subgraph.records];
 }
 function applyFilters(records, options) {
     const kind = normalizeKind(options.kind);
@@ -95,6 +96,89 @@ function matchesQuery(record, query) {
     const text = capabilitySearchText(record);
     return terms.every((term) => text.includes(term));
 }
+function recordSource(record) {
+    const source = record.source;
+    return source ?? {};
+}
+function isStale(record) {
+    return recordSource(record).stale === true;
+}
+function hasReadPermission(record) {
+    const permissions = recordSource(record).permissions;
+    return !Array.isArray(permissions) || permissions.includes("read");
+}
+function requirementMatch(record, required) {
+    if (!required) {
+        return 0;
+    }
+    const normalized = required.toLowerCase();
+    const haystack = [
+        ...record.refs,
+        ...record.tags,
+        JSON.stringify(record.spec ?? {}),
+        JSON.stringify(record.work ?? {}),
+        JSON.stringify(record.skill ?? {}),
+    ]
+        .join(" ")
+        .toLowerCase();
+    return haystack.includes(normalized) ? 1 : 0;
+}
+function linkageScore(record) {
+    let score = 0;
+    if (record.kind === "work") {
+        score += 2;
+    }
+    if (record.kind === "spec") {
+        score += 1;
+    }
+    if (record.work || record.spec) {
+        score += 1;
+    }
+    return score;
+}
+function resolveScore(record, options) {
+    let score = 0;
+    if (record.workspace === "root") {
+        score += 1000;
+    }
+    if (!isStale(record)) {
+        score += 500;
+    }
+    if (hasReadPermission(record)) {
+        score += 100;
+    }
+    if (options.query && matchesQuery(record, options.query)) {
+        score += 50;
+    }
+    score += requirementMatch(record, options.requires) * 25;
+    score += linkageScore(record);
+    return score;
+}
+function resolveCapabilities(records, options) {
+    const filtered = records.filter((record) => {
+        if (options.freshOnly && isStale(record)) {
+            return false;
+        }
+        if (options.query && !matchesQuery(record, options.query)) {
+            return false;
+        }
+        if (options.requires && requirementMatch(record, options.requires) === 0) {
+            return false;
+        }
+        return true;
+    });
+    return filtered.sort((a, b) => {
+        const scoreDelta = resolveScore(b, options) - resolveScore(a, options);
+        if (scoreDelta !== 0) {
+            return scoreDelta;
+        }
+        const qidDelta = a.qid.localeCompare(b.qid);
+        if (qidDelta !== 0) {
+            return qidDelta;
+        }
+        return a.path.localeCompare(b.path);
+    });
+}
 function printCapabilityList(records, json, query) {
     if (json) {
         console.log(JSON.stringify({
@@ -160,3 +244,33 @@ function runCapabilityShowCommand(options) {
     const records = loadRecords(options);
     printCapability(resolveCapability(records, options.id), options.json);
 }
+function runCapabilityResolveCommand(options) {
+    const records = applyFilters(loadRecords(options), options);
+    const items = resolveCapabilities(records, options).map((record, rank) => ({
+        rank: rank + 1,
+        score: resolveScore(record, options),
+        stale: isStale(record),
+        item: record,
+    }));
+    if (options.json) {
+        console.log(JSON.stringify({
+            kind: "capability.resolve",
+            query: options.query,
+            requires: options.requires,
+            fresh_only: options.freshOnly === true,
+            count: items.length,
+            items,
+        }, null, 2));
+        return;
+    }
+    if (items.length === 0) {
+        console.log("no capabilities resolved");
+        return;
+    }
+    console.log(`resolved capabilities: ${items.length}`);
+    for (const result of items) {
+        const record = result.item;
+        const stale = result.stale ? " stale" : "";
+        console.log(`${result.rank}. ${record.qid} | score ${result.score}${stale} | ${record.kind} | ${record.title}`);
+    }
+}

package/dist/commands/doctor.js

@@ -9,7 +9,7 @@ const path_1 = __importDefault(require("path"));
 const config_1 = require("../core/config");
 const index_cache_1 = require("../graph/index_cache");
 const capabilities_index_cache_1 = require("../graph/capabilities_index_cache");
-const bundle_imports_1 = require("../graph/bundle_imports");
+const subgraphs_1 = require("../graph/subgraphs");
 const node_1 = require("../graph/node");
 const template_schema_1 = require("../graph/template_schema");
 const visibility_1 = require("../graph/visibility");
@@ -186,45 +186,45 @@ function runBundleStorageCheck(root, outputDir) {
         detail: `${bundles.length} bundle(s) found; run \`mdkg bundle verify <path>\` to check freshness before handoff`,
     };
 }
-function runBundleImportChecks(root, config) {
-    const projection = (0, bundle_imports_1.buildBundleImportsIndex)(root, config);
-    if (projection.index.imports.length === 0) {
+function runSubgraphChecks(root, config) {
+    const projection = (0, subgraphs_1.buildSubgraphsIndex)(root, config);
+    if (projection.index.subgraphs.length === 0) {
         return [
             {
-                name: "bundle-imports",
+                name: "subgraphs",
                 ok: true,
-                detail: "no bundle imports configured",
+                detail: "no subgraphs configured",
             },
         ];
     }
-    return projection.index.imports.map((item) => {
+    return projection.index.subgraphs.map((item) => {
         if (!item.enabled) {
             return {
-                name: `bundle-import:${item.alias}`,
+                name: `subgraph:${item.alias}`,
                 ok: true,
                 level: "warn",
-                detail: `disabled import at ${item.path}`,
+                detail: "disabled subgraph",
             };
         }
         if (item.error_count > 0) {
             return {
-                name: `bundle-import:${item.alias}`,
+                name: `subgraph:${item.alias}`,
                 ok: false,
                 detail: item.errors.join("; "),
             };
         }
         if (item.stale || item.warning_count > 0) {
             return {
-                name: `bundle-import:${item.alias}`,
+                name: `subgraph:${item.alias}`,
                 ok: true,
                 level: "warn",
-                detail: `import is stale or has warnings; run \`mdkg bundle import verify ${item.alias}\` (${item.warnings.join("; ")})`,
+                detail: `subgraph is stale or has warnings; run \`mdkg subgraph verify ${item.alias}\` (${item.warnings.join("; ")})`,
             };
         }
         return {
-            name: `bundle-import:${item.alias}`,
+            name: `subgraph:${item.alias}`,
             ok: true,
-            detail: `import loaded from ${item.path}`,
+            detail: `subgraph loaded from ${item.sources.map((source) => source.path).join(", ")}`,
         };
     });
 }
@@ -299,7 +299,7 @@ function runDoctorCommand(options) {
         results.push(runArchiveLargeCacheCheck(options.root, config.archive.large_cache_warning_bytes));
         results.push(runBundleStorageCheck(options.root, config.bundles.output_dir));
         results.push(runSqliteCheck(options.root, config));
-        results.push(...runBundleImportChecks(options.root, config));
+        results.push(...runSubgraphChecks(options.root, config));
         results.push(runVisibilityPolicyCheck(options.root, config, options));
         try {
             const templateSchemaInfo = (0, template_schema_1.loadTemplateSchemasWithInfo)(options.root, config, node_1.ALLOWED_TYPES);