mdkg 0.1.1 → 0.1.2

package/dist/commands/pack.js

@@ -11,6 +11,7 @@ const index_cache_1 = require("../graph/index_cache");
 const frontmatter_1 = require("../graph/frontmatter");
 const skills_index_cache_1 = require("../graph/skills_index_cache");
 const node_1 = require("../graph/node");
+const visibility_1 = require("../graph/visibility");
 const budget_1 = require("../pack/budget");
 const export_json_1 = require("../pack/export_json");
 const export_md_1 = require("../pack/export_md");
@@ -217,6 +218,53 @@ function applyNodeCountLimit(pack, maxNodes) {
         nodes: included,
     };
 }
+function packNodeVisibility(node, index, config) {
+    const indexNode = index.nodes[node.qid];
+    if (indexNode) {
+        return (0, visibility_1.effectiveNodeVisibility)(indexNode, config);
+    }
+    return (0, visibility_1.normalizeVisibility)(config.workspaces[node.workspace]?.visibility, "workspace visibility");
+}
+function applyVisibilityFilter(pack, index, config, scope) {
+    if (scope === "private") {
+        return {
+            ...pack,
+            meta: {
+                ...pack.meta,
+                visibility: scope,
+            },
+        };
+    }
+    const includedNodes = pack.nodes.filter((node) => (0, visibility_1.isVisibleAt)(packNodeVisibility(node, index, config), scope));
+    if (includedNodes.length === 0 || includedNodes[0].qid !== pack.nodes[0]?.qid) {
+        throw new errors_1.ValidationError(`pack root ${pack.meta.root} is not visible at ${scope}`);
+    }
+    const includedQids = new Set(includedNodes.map((node) => node.qid));
+    const graphIncludedQids = new Set(includedNodes.filter((node) => Boolean(index.nodes[node.qid])).map((node) => node.qid));
+    const violations = (0, visibility_1.collectVisibilityViolations)(index, config, {
+        includedQids: graphIncludedQids,
+        scope,
+    });
+    if (violations.length > 0) {
+        throw new errors_1.ValidationError(`${scope} pack contains less-visible references:\n${(0, visibility_1.visibilityViolationMessages)(violations).join("\n")}`);
+    }
+    const dropped = pack.nodes
+        .filter((node) => !includedQids.has(node.qid))
+        .map((node) => node.qid);
+    return {
+        ...pack,
+        meta: {
+            ...pack.meta,
+            visibility: scope,
+            node_count: includedNodes.length,
+            truncated: {
+                ...pack.meta.truncated,
+                dropped: [...pack.meta.truncated.dropped, ...dropped],
+            },
+        },
+        nodes: includedNodes,
+    };
+}
 function writeJsonFile(outPath, payload) {
     fs_1.default.mkdirSync(path_1.default.dirname(outPath), { recursive: true });
     fs_1.default.writeFileSync(outPath, JSON.stringify(payload, null, 2), "utf8");
@@ -243,6 +291,9 @@ function printDryRunSummary(pack, stats, format) {
     console.log(`root: ${pack.meta.root}`);
     console.log(`profile: ${pack.meta.profile ?? "standard"}`);
     console.log(`body_mode: ${pack.meta.body_mode ?? "full"}`);
+    if (pack.meta.visibility) {
+        console.log(`visibility: ${pack.meta.visibility}`);
+    }
     console.log(`format: ${format}`);
     console.log(`nodes: ${pack.nodes.length}`);
     if (pack.meta.latest_checkpoint_qid) {
@@ -267,10 +318,10 @@ function printDryRunSummary(pack, stats, format) {
 function runPackCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
-    if (ws && !config.workspaces[ws]) {
+    if (ws && !config.workspaces[ws] && !config.bundle_imports[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
-    const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
+    const { index, rebuilt, stale, warnings } = (0, index_cache_1.loadIndex)({
         root: options.root,
         config,
         useCache: !options.noCache,
@@ -279,6 +330,9 @@ function runPackCommand(options) {
     if (stale && !rebuilt && !options.noCache) {
         console.error("warning: index is stale; run mdkg index to refresh");
     }
+    for (const warning of warnings) {
+        console.error(`warning: ${warning}`);
+    }
     const resolved = (0, qid_1.resolveQid)(index, options.id, ws);
     if (resolved.status !== "ok") {
         throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("id", options.id, resolved, ws));
@@ -291,6 +345,9 @@ function runPackCommand(options) {
     const edges = normalizeEdges([...config.pack.default_edges, ...extraEdges]);
     const skillsPolicy = resolveSkillsPolicy(options.skills);
     const skillsDepth = resolveSkillsDepth(options.skillsDepth);
+    const visibility = options.visibility
+        ? (0, visibility_1.normalizeVisibility)(options.visibility)
+        : undefined;
     let resolvedProfile;
     try {
         resolvedProfile = (0, profile_1.resolvePackProfile)({
@@ -350,6 +407,9 @@ function runPackCommand(options) {
         packWithSkills = appendSkillsToPack(packWithSkills, selectedEntries, skillsDepth, options.root);
         packWithSkills = applyNodeCountLimit(packWithSkills, config.pack.limits.max_nodes);
     }
+    if (visibility) {
+        packWithSkills = applyVisibilityFilter(packWithSkills, index, config, visibility);
+    }
     const templateHeadingMap = resolvedProfile.bodyMode === "summary"
         ? (0, headings_1.loadTemplateHeadingMap)(options.root, config, Array.from(node_1.ALLOWED_TYPES))
         : {};

package/dist/commands/query_output.js

@@ -36,6 +36,7 @@ function toNodeSummaryJson(node) {
             blocked_by: [...node.edges.blocked_by],
             blocks: [...node.edges.blocks],
         },
+        ...(node.source ? { source: node.source } : {}),
     };
 }
 function toNodeDetailJson(node, body) {

package/dist/commands/search.js

@@ -54,14 +54,14 @@ function runSearchCommand(options) {
     }
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
-    if (ws && !config.workspaces[ws]) {
+    if (ws && !config.workspaces[ws] && !config.bundle_imports[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
     const normalizedType = options.type?.toLowerCase();
     if (normalizedType === "skill") {
         throw new errors_1.UsageError("--type skill is no longer supported here; use `mdkg skill search`");
     }
-    const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
+    const { index, rebuilt, stale, warnings } = (0, index_cache_1.loadIndex)({
         root: options.root,
         config,
         useCache: !options.noCache,
@@ -70,6 +70,9 @@ function runSearchCommand(options) {
     if (stale && !rebuilt && !options.noCache) {
         console.error("warning: index is stale; run mdkg index to refresh");
     }
+    for (const warning of warnings) {
+        console.error(`warning: ${warning}`);
+    }
     const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
     const nodeResults = (0, filter_1.filterNodes)(Object.values(index.nodes), {
         ws,

package/dist/commands/show.js

@@ -1,14 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runShowCommand = runShowCommand;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const config_1 = require("../core/config");
 const index_cache_1 = require("../graph/index_cache");
-const frontmatter_1 = require("../graph/frontmatter");
+const node_body_1 = require("../graph/node_body");
 const errors_1 = require("../util/errors");
 const qid_1 = require("../util/qid");
 const node_card_1 = require("./node_card");
@@ -34,14 +29,14 @@ function formatAttributeLine(key, value) {
 function runShowCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const ws = normalizeWorkspace(options.ws);
-    if (ws && !config.workspaces[ws]) {
+    if (ws && !config.workspaces[ws] && !config.bundle_imports[ws]) {
         throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
     }
     const normalizedId = options.id.toLowerCase();
     if (normalizedId.startsWith("skill:") || normalizedId.startsWith("root:skill:")) {
         throw new errors_1.UsageError(`generic skill show is no longer supported; use \`mdkg skill show ${options.id.replace(/^root:skill:|^skill:/i, "")}\``);
     }
-    const { index, rebuilt, stale } = (0, index_cache_1.loadIndex)({
+    const { index, rebuilt, stale, warnings } = (0, index_cache_1.loadIndex)({
         root: options.root,
         config,
         useCache: !options.noCache,
@@ -50,19 +45,17 @@ function runShowCommand(options) {
     if (stale && !rebuilt && !options.noCache) {
         console.error("warning: index is stale; run mdkg index to refresh");
     }
+    for (const warning of warnings) {
+        console.error(`warning: ${warning}`);
+    }
     const resolved = (0, qid_1.resolveQid)(index, options.id, ws);
     if (resolved.status !== "ok") {
         throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("id", options.id, resolved, ws));
     }
     const node = index.nodes[resolved.qid];
-    const filePath = path_1.default.resolve(options.root, node.path);
     let body = "";
     if (!options.metaOnly) {
-        if (!fs_1.default.existsSync(filePath)) {
-            throw new errors_1.NotFoundError(`file not found for ${node.qid}: ${node.path}`);
-        }
-        const content = fs_1.default.readFileSync(filePath, "utf8");
-        body = (0, frontmatter_1.parseFrontmatter)(content, filePath).body.trimEnd();
+        body = (0, node_body_1.readNodeBody)(options.root, node);
     }
     const format = options.format ?? (options.json ? "json" : undefined);
     if (format) {

package/dist/commands/skill_mirror.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.syncSkillMirrors = syncSkillMirrors;
+exports.preflightSkillMirrorTargets = preflightSkillMirrorTargets;
 exports.shouldMaintainSkillMirrors = shouldMaintainSkillMirrors;
 exports.auditSkillMirrors = auditSkillMirrors;
 exports.scaffoldMirrorRoots = scaffoldMirrorRoots;
@@ -271,6 +272,27 @@ function syncSkillMirrors(options) {
     }
     return { synced, pruned, targets: touchedTargets };
 }
+function preflightSkillMirrorTargets(options) {
+    if (options.force) {
+        return;
+    }
+    const slugs = Array.from(new Set(options.slugs.map((value) => value.trim().toLowerCase()).filter(Boolean)));
+    if (slugs.length === 0) {
+        return;
+    }
+    for (const target of resolveMirrorTargets(options.root)) {
+        if (!fs_1.default.existsSync(target.rootDir) && !fs_1.default.existsSync(target.skillsRoot)) {
+            continue;
+        }
+        const managed = readManifest(target);
+        for (const slug of slugs) {
+            const destDir = path_1.default.join(target.skillsRoot, slug);
+            if (fs_1.default.existsSync(destDir) && !managed.has(slug)) {
+                throw new errors_1.UsageError(`${path_1.default.relative(options.root, destDir)} already exists and is not mdkg-managed; rerun \`mdkg init --agent --force\` or \`mdkg skill sync --force\` to replace it`);
+            }
+        }
+    }
+}
 function shouldMaintainSkillMirrors(root) {
     return shouldCreateMirrorRoots(root);
 }

package/dist/commands/task.js

@@ -107,6 +107,9 @@ function loadMutableTaskNode(root, idOrQid, wsHint) {
     if (!node) {
         throw new errors_1.NotFoundError(`task not found: ${idOrQid}`);
     }
+    if (node.source?.imported) {
+        throw new errors_1.UsageError(`cannot mutate read-only imported node ${node.qid}; update the source workspace for bundle import ${node.source.import_alias}`);
+    }
     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}`);
     }

package/dist/commands/upgrade.js

@@ -18,6 +18,7 @@ const skill_mirror_1 = require("./skill_mirror");
 const DEFAULT_SEED_SUBDIR = path_1.default.resolve(__dirname, "..", "init");
 const PROTECTED_CORE_DOCS = new Set([".mdkg/core/SOUL.md", ".mdkg/core/HUMAN.md"]);
 const CREATE_ONLY_PRESERVED = new Set([".mdkg/core/core.md"]);
+const ARCHIVE_RAW_IGNORE_ENTRIES = [".mdkg/archive/**/source/"];
 function seededInitEvent(nowIso) {
     const event = {
         ts: nowIso,
@@ -107,7 +108,7 @@ function buildKnownHashes(manifests) {
     return hashes;
 }
 function shouldIncludeFile(file, agentWorkspace) {
-    if (file.category === "default_skill") {
+    if (file.category === "agent_doc" || file.category === "startup_doc" || file.category === "default_skill") {
         return agentWorkspace;
     }
     return file.category !== "config";
@@ -254,6 +255,27 @@ function ensureAgentRuntimeFiles(root, dryRun, summary, changes) {
         summary.unchanged += 1;
     }
 }
+function ensureArchiveIgnorePolicy(root, dryRun, summary, changes) {
+    const ignorePath = path_1.default.join(root, ".gitignore");
+    const raw = fs_1.default.existsSync(ignorePath) ? fs_1.default.readFileSync(ignorePath, "utf8") : "";
+    const lines = raw.split(/\r?\n/);
+    const existing = new Set(lines.map((line) => line.trim()).filter(Boolean));
+    const additions = ARCHIVE_RAW_IGNORE_ENTRIES.filter((entry) => !existing.has(entry));
+    if (additions.length === 0) {
+        summary.unchanged += 1;
+        return;
+    }
+    record(summary, changes, {
+        path: ".gitignore",
+        category: "ignore_policy",
+        action: fs_1.default.existsSync(ignorePath) ? "update" : "create",
+        reason: "ignore raw local archive source copies while keeping sidecars and zip caches commit-eligible",
+    });
+    if (!dryRun) {
+        const suffix = raw.length === 0 || raw.endsWith("\n") ? "" : "\n";
+        writeFile(ignorePath, `${raw}${suffix}${additions.join("\n")}\n`);
+    }
+}
 function isWritableChange(change) {
     return change.action === "create" || change.action === "update" || change.action === "migrate" || change.action === "sync";
 }
@@ -353,6 +375,7 @@ function runUpgradeCommand(options) {
     if (agentWorkspace) {
         ensureAgentRuntimeFiles(root, dryRun, summary, changes);
     }
+    ensureArchiveIgnorePolicy(root, dryRun, summary, changes);
     const applySideEffects = buildApplySideEffects({
         existingManifest,
         agentWorkspace,

package/dist/commands/validate.js

@@ -12,6 +12,8 @@ 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 bundle_imports_1 = require("../graph/bundle_imports");
+const visibility_1 = require("../graph/visibility");
 const errors_1 = require("../util/errors");
 const skill_mirror_1 = require("./skill_mirror");
 const RECOMMENDED_HEADINGS = {
@@ -268,6 +270,16 @@ function runValidateCommand(options) {
         nodes,
         reverse_edges: {},
     };
+    const importProjection = (0, bundle_imports_1.buildBundleImportsIndex)(options.root, config);
+    for (const item of importProjection.index.imports) {
+        for (const warning of item.warnings) {
+            warnings.push(`bundle import ${item.alias}: ${warning}`);
+        }
+        for (const error of item.errors) {
+            errors.push(`bundle import ${item.alias}: ${error}`);
+        }
+    }
+    const validationIndex = (0, bundle_imports_1.mergeBundleImportsIntoIndex)(index, importProjection);
     let knownSkills = new Set();
     try {
         const skillsIndex = (0, skills_indexer_1.buildSkillsIndex)(options.root, config);
@@ -284,11 +296,12 @@ function runValidateCommand(options) {
         const message = err instanceof Error ? err.message : "unknown skill validation error";
         errors.push(message);
     }
-    const graphErrors = (0, validate_graph_1.collectGraphErrors)(index, {
+    const graphErrors = (0, validate_graph_1.collectGraphErrors)(validationIndex, {
         allowMissing: false,
         knownSkillSlugs: knownSkills,
     });
     errors.push(...graphErrors);
+    errors.push(...(0, visibility_1.visibilityViolationMessages)((0, visibility_1.collectVisibilityViolations)(validationIndex, config)).map((message) => `visibility: ${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");