mixdog 0.9.151 → 0.9.152

package/src/runtime/agent/orchestrator/context/collect-skills.test.mjs

@@ -0,0 +1,153 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import {
+  collectSkillsCached,
+  invalidateSkillsCache,
+  loadSkillResource,
+} from './collect.mjs';
+
+test('discovers global standard skill folders and ignores project-local skills and reference Markdown', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-standard-skill-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = join(root, 'data');
+  try {
+    const cwd = join(root, 'project');
+    const skillDir = join(process.env.MIXDOG_DATA_DIR, 'skills', 'copied-skill');
+    const projectSkillDir = join(cwd, '.mixdog', 'skills', 'project-only');
+    mkdirSync(join(skillDir, 'references'), { recursive: true });
+    mkdirSync(join(skillDir, 'scripts'), { recursive: true });
+    mkdirSync(projectSkillDir, { recursive: true });
+    writeFileSync(join(skillDir, 'SKILL.md'), [
+      '---',
+      'name: copied-skill',
+      'description: >',
+      '  Use when a copied standard skill',
+      '  should be discovered.',
+      'metadata:',
+      '  source: external',
+      '---',
+      '',
+      '# Instructions',
+      '',
+      'Read `references/guide.md` and run `scripts/check.py` when needed.',
+      '',
+    ].join('\n'));
+    writeFileSync(join(skillDir, 'references', 'guide.md'), [
+      '---',
+      'name: not-a-skill',
+      'description: This reference must never become a skill.',
+      '---',
+      '',
+      '# Reference',
+      '',
+    ].join('\n'));
+    writeFileSync(join(skillDir, 'scripts', 'check.py'), 'print("ok")\n');
+    writeFileSync(join(projectSkillDir, 'SKILL.md'), [
+      '---',
+      'name: project-only',
+      'description: This project-local skill must be ignored.',
+      '---',
+      '',
+      '# Project instructions',
+      '',
+    ].join('\n'));
+
+    invalidateSkillsCache(cwd);
+    const copied = collectSkillsCached(cwd)
+      .find((skill) => skill.name === 'copied-skill');
+    assert.ok(copied);
+    assert.equal(copied.description,
+      'Use when a copied standard skill should be discovered.');
+    assert.equal(collectSkillsCached(cwd)
+      .some((skill) => skill.name === 'not-a-skill'), false);
+    assert.equal(collectSkillsCached(cwd)
+      .some((skill) => skill.name === 'project-only'), false);
+
+    const loaded = loadSkillResource('copied-skill', cwd);
+    assert.match(loaded.content, /^# Instructions/);
+    assert.equal(loaded.dir, skillDir);
+    assert.equal(existsSync(join(loaded.dir, 'references', 'guide.md')), true);
+    assert.equal(existsSync(join(loaded.dir, 'scripts', 'check.py')), true);
+  } finally {
+    invalidateSkillsCache(join(root, 'project'));
+    if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('loads skills only from globally enabled plugins', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-plugin-skill-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = join(root, 'data');
+  try {
+    const enabledRoot = join(root, 'enabled-plugin');
+    const disabledRoot = join(root, 'disabled-plugin');
+    const writeSkill = (pluginRoot, name) => {
+      const dir = join(pluginRoot, 'skills', name);
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, 'SKILL.md'), [
+        '---',
+        `name: ${name}`,
+        `description: Use when ${name} is needed.`,
+        '---',
+        '',
+        '# Instructions',
+        '',
+      ].join('\n'));
+    };
+    writeSkill(enabledRoot, 'enabled-plugin-skill');
+    writeSkill(disabledRoot, 'disabled-plugin-skill');
+    const registryDir = join(process.env.MIXDOG_DATA_DIR, 'plugins');
+    mkdirSync(registryDir, { recursive: true });
+    writeFileSync(join(registryDir, 'registry.json'), JSON.stringify({
+      plugins: [
+        { id: 'enabled', root: enabledRoot, enabled: true },
+        { id: 'disabled', root: disabledRoot, enabled: false },
+      ],
+    }));
+
+    invalidateSkillsCache();
+    const names = collectSkillsCached(join(root, 'any-project')).map((skill) => skill.name);
+    assert.equal(names.includes('enabled-plugin-skill'), true);
+    assert.equal(names.includes('disabled-plugin-skill'), false);
+  } finally {
+    invalidateSkillsCache();
+    if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('requires a standard folder name that matches the manifest name', () => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-mismatched-skill-'));
+  const previousDataDir = process.env.MIXDOG_DATA_DIR;
+  process.env.MIXDOG_DATA_DIR = join(root, 'data');
+  try {
+    const cwd = join(root, 'project');
+    const skillDir = join(process.env.MIXDOG_DATA_DIR, 'skills', 'folder-name');
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, 'SKILL.md'), [
+      '---',
+      'name: different-name',
+      'description: Use when testing mismatched folders.',
+      '---',
+      '',
+      '# Instructions',
+      '',
+    ].join('\n'));
+
+    invalidateSkillsCache(cwd);
+    assert.equal(collectSkillsCached(cwd)
+      .some((skill) => skill.name === 'different-name'), false);
+  } finally {
+    invalidateSkillsCache(join(root, 'project'));
+    if (previousDataDir === undefined) delete process.env.MIXDOG_DATA_DIR;
+    else process.env.MIXDOG_DATA_DIR = previousDataDir;
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/runtime/agent/orchestrator/context/collect.mjs

@@ -1,12 +1,10 @@
 import { readFileSync, existsSync, readdirSync } from 'fs';
 import { homedir } from 'os';
-import { dirname, join } from 'path';
+import { basename, dirname, join } from 'path';
 import { maxMtimeRecursive } from '../cache-mtime.mjs';
 import { resolvePluginData, mixdogRoot } from '../../../shared/plugin-paths.mjs';
-import {
-    parseMarkdownFrontmatter,
-    readMarkdownDocument,
-} from '../../../shared/markdown-frontmatter.mjs';
+import { readMarkdownDocument } from '../../../shared/markdown-frontmatter.mjs';
+import { parseSkillDocument } from '../../../shared/skill-document.mjs';
 import { loadConfig, normalizeSkillsConfig } from '../config.mjs';
 
 function skillsDisabled() {
@@ -14,8 +12,8 @@ function skillsDisabled() {
 }
 
 // --- mixdog asset roots (standalone CLI owns its own paths; never .claude) ---
-// Project-local:  <cwd>/.mixdog/<kind>
-// Data-local:     <mixdogData>/<kind>   (standalone default: ~/.mixdog/data/<kind>)
+// Skills are machine-global under <mixdogData>/skills. Project-local skill
+// directories are intentionally outside the runtime resolution chain.
 function mixdogHome() {
     return process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
 }
@@ -27,16 +25,8 @@ function mixdogGlobalDir(kind) {
         return join(process.env.MIXDOG_DATA_DIR || join(mixdogHome(), 'data'), kind);
     }
 }
-function mixdogProjectDir(projectDir, kind) {
-    return projectDir ? join(projectDir, '.mixdog', kind) : null;
-}
-/** Ordered asset search dirs for a kind: project-local first, then global. */
-function mixdogAssetDirs(projectDir, kind) {
-    const dirs = [];
-    const local = mixdogProjectDir(projectDir, kind);
-    if (local) dirs.push(local);
-    dirs.push(mixdogGlobalDir(kind));
-    return dirs;
+function mixdogAssetDirs(_projectDir, kind) {
+    return [mixdogGlobalDir(kind)];
 }
 /**
  * Absolute path to the plugin registry file, or null when the data dir is
@@ -70,6 +60,8 @@ function pluginSkillDirs() {
         return [];
     const dirs = [];
     for (const entry of registry.plugins) {
+        if (entry?.enabled === false)
+            continue;
         const root = entry && typeof entry.root === 'string' ? entry.root : null;
         if (!root || !existsSync(root))
             continue;
@@ -85,19 +77,11 @@ function pluginSkillDirs() {
  */
 export function collectSkills(cwd) {
     if (skillsDisabled()) return [];
-    // When cwd is null/missing (e.g. agent maintenance callers that pass
-    // cwd:null on purpose so provider-cache shards don't fork per caller
-    // workspace), skip project-scoped skills entirely — DO NOT fall back
-    // to process.cwd(), which would leak the MCP launch dir into the
-    // shard key and fragment the cache.
-    const projectDir = (typeof cwd === 'string' && cwd.length > 0) ? cwd : null;
+    void cwd;
     const skills = [];
-    // mixdog-owned only (never .claude): project-local <cwd>/.mixdog/skills
-    // first, then user-global. When cwd is missing, only the global dir is
-    // searched.
-    const dirs = mixdogAssetDirs(projectDir, 'skills');
-    // Plugin-provided skills load last so project-local and global mixdog
-    // skill dirs keep precedence; `seen` below dedupes by frontmatter name.
+    const dirs = mixdogAssetDirs(null, 'skills');
+    // Plugin-provided skills load last so user-global skills keep precedence;
+    // `seen` below dedupes by frontmatter name.
     dirs.push(...pluginSkillDirs());
     const seen = new Set();
     for (const dir of dirs) {
@@ -106,21 +90,27 @@ export function collectSkills(cwd) {
         try {
             const files = readdirSync(dir, { recursive: true });
             for (const f of files) {
-                if (!String(f).endsWith('.md'))
+                if (basename(String(f)) !== 'SKILL.md')
                     continue;
                 const filePath = join(dir, String(f));
                 const content = readSafe(filePath);
                 if (!content)
                     continue;
-                const fm = parseMarkdownFrontmatter(content);
-                if (!fm.name)
+                let skill;
+                try {
+                    skill = parseSkillDocument(content);
+                } catch {
                     continue;
-                if (seen.has(fm.name))
+                }
+                // Agent Skills requires the manifest name to match its folder.
+                if (basename(dirname(filePath)) !== skill.name)
                     continue;
-                seen.add(fm.name);
+                if (seen.has(skill.name))
+                    continue;
+                seen.add(skill.name);
                 skills.push({
-                    name: fm.name,
-                    description: fm.description || '',
+                    name: skill.name,
+                    description: skill.description,
                     filePath,
                 });
             }
@@ -167,10 +157,10 @@ const _mtimeCache = new Map();
 const _MTIME_TTL_MS = 2000;
 export function collectSkillsCached(cwd) {
     if (skillsDisabled()) return [];
-    const key = cwd ?? '';
-    const projectDir = (typeof cwd === 'string' && cwd.length > 0) ? cwd : null;
+    void cwd;
+    const key = 'global';
     // Same mixdog-owned dirs collectSkills() reads, used as the freshness gate.
-    const skillsDirs = mixdogAssetDirs(projectDir, 'skills');
+    const skillsDirs = mixdogAssetDirs(null, 'skills');
     skillsDirs.push(...pluginSkillDirs());
     // registry.json itself gates plugin add/remove: removal deletes the
     // plugin's skills dir (so no dir mtime advances), but saveRegistry()
@@ -200,6 +190,11 @@ export function collectSkillsCached(cwd) {
     }
     return skills;
 }
+export function invalidateSkillsCache(cwd) {
+    void cwd;
+    _skillsCache.clear();
+    _mtimeCache.clear();
+}
 /**
  * Load full skill content by name.
  */
@@ -209,7 +204,12 @@ function loadSkillContent(name, cwd) {
     if (!skill)
         return null;
     const content = readSafe(skill.filePath);
-    return content == null ? null : readMarkdownDocument(content).body;
+    if (content == null) return null;
+    try {
+        return parseSkillDocument(content).body;
+    } catch {
+        return null;
+    }
 }
 
 /**
@@ -226,11 +226,15 @@ export function loadSkillResource(name, cwd) {
     const content = readSafe(skill.filePath);
     if (content == null)
         return null;
-    return {
-        content: readMarkdownDocument(content).body,
-        dir: dirname(skill.filePath),
-        filePath: skill.filePath,
-    };
+    try {
+        return {
+            content: parseSkillDocument(content).body,
+            dir: dirname(skill.filePath),
+            filePath: skill.filePath,
+        };
+    } catch {
+        return null;
+    }
 }
 
 function escapeSkillXmlText(value) {