agentpacks 0.9.0 → 1.0.0

package/dist/node/cli/import-cmd.js

@@ -129,15 +129,105 @@ function serializeFrontmatter(data, content) {
   return matter.stringify(content, filtered);
 }
 
+// src/features/skills.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { basename, join as join2 } from "path";
+var SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SKILL_NAME_MAX_LENGTH = 64;
+function parseSkills(skillsDir, packName) {
+  const dirs = listDirs(skillsDir);
+  const skills = [];
+  for (const dir of dirs) {
+    const skillMd = join2(dir, "SKILL.md");
+    if (existsSync2(skillMd)) {
+      skills.push(parseSkillFile(skillMd, dir, packName));
+    }
+  }
+  return skills;
+}
+function parseSkillFile(filepath, skillDir, packName) {
+  const raw = readFileSync2(filepath, "utf-8");
+  const { data, content } = parseFrontmatter(raw);
+  return {
+    name: data.name ?? basename(skillDir),
+    sourcePath: filepath,
+    sourceDir: skillDir,
+    packName,
+    meta: data,
+    content
+  };
+}
+function buildSkillFrontmatter(skill) {
+  return {
+    ...skill.meta,
+    name: skill.name
+  };
+}
+function serializeSkill(skill) {
+  return serializeFrontmatter(buildSkillFrontmatter(skill), skill.content);
+}
+function normalizeImportedSkillMarkdown(source, skillName) {
+  const { data, content } = parseFrontmatter(source);
+  const normalized = {
+    ...data,
+    name: skillName
+  };
+  let addedDescription = false;
+  const description = normalized.description;
+  if (typeof description !== "string" || description.trim().length === 0) {
+    normalized.description = `Imported skill: ${skillName}`;
+    addedDescription = true;
+  }
+  return {
+    content: serializeFrontmatter(normalized, content),
+    addedDescription
+  };
+}
+function validateAgentSkillsFrontmatter(skill) {
+  const errors = [];
+  const dirName = basename(skill.sourceDir);
+  const declaredName = skill.meta.name;
+  if (typeof declaredName !== "string" || declaredName.trim().length === 0) {
+    errors.push('Missing required frontmatter field "name".');
+  } else {
+    if (declaredName.length > SKILL_NAME_MAX_LENGTH) {
+      errors.push(`Invalid "name": must be at most ${SKILL_NAME_MAX_LENGTH} characters.`);
+    }
+    if (!SKILL_NAME_PATTERN.test(declaredName)) {
+      errors.push('Invalid "name": use lowercase letters, numbers, and single hyphens only.');
+    }
+    if (declaredName !== dirName) {
+      errors.push(`Invalid "name": must match containing directory "${dirName}".`);
+    }
+  }
+  const description = skill.meta.description;
+  if (typeof description !== "string" || description.trim().length === 0) {
+    errors.push('Missing required frontmatter field "description".');
+  }
+  const allowedTools = skill.meta["allowed-tools"];
+  if (allowedTools !== undefined && (!Array.isArray(allowedTools) || allowedTools.some((tool) => typeof tool !== "string" || tool.length === 0))) {
+    errors.push('Invalid "allowed-tools": expected an array of non-empty strings.');
+  }
+  return errors;
+}
+function skillMatchesTarget(skill, targetId) {
+  const { targets } = skill.meta;
+  if (!targets || targets === "*")
+    return true;
+  if (Array.isArray(targets) && targets.includes("*"))
+    return true;
+  return Array.isArray(targets) && targets.includes(targetId);
+}
+
 // src/importers/rulesync.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, copyFileSync, writeFileSync as writeFileSync2 } from "fs";
-import { resolve, join as join2, basename } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, copyFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve, join as join3, basename as basename2 } from "path";
 import { parse as parseJsonc } from "jsonc-parser";
 function importFromRulesync(projectRoot, outputPackDir) {
   const rulesyncDir = resolve(projectRoot, ".rulesync");
   const warnings = [];
   const filesImported = [];
-  if (!existsSync2(rulesyncDir)) {
+  if (!existsSync3(rulesyncDir)) {
     return {
       packDir: "",
       filesImported: [],
@@ -148,76 +238,82 @@ function importFromRulesync(projectRoot, outputPackDir) {
   const packDir = outputPackDir ?? resolve(projectRoot, "packs", "default");
   ensureDir(packDir);
   const rulesDir = resolve(rulesyncDir, "rules");
-  if (existsSync2(rulesDir)) {
+  if (existsSync3(rulesDir)) {
     const outRulesDir = resolve(packDir, "rules");
     ensureDir(outRulesDir);
     const files = listFiles(rulesDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join2(outRulesDir, basename(file));
+      const dest = join3(outRulesDir, basename2(file));
       copyFileSync(file, dest);
       filesImported.push(dest);
     }
   }
   const commandsDir = resolve(rulesyncDir, "commands");
-  if (existsSync2(commandsDir)) {
+  if (existsSync3(commandsDir)) {
     const outCommandsDir = resolve(packDir, "commands");
     ensureDir(outCommandsDir);
     const files = listFiles(commandsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join2(outCommandsDir, basename(file));
+      const dest = join3(outCommandsDir, basename2(file));
       copyFileSync(file, dest);
       filesImported.push(dest);
     }
   }
   const subagentsDir = resolve(rulesyncDir, "subagents");
-  if (existsSync2(subagentsDir)) {
+  if (existsSync3(subagentsDir)) {
     const outAgentsDir = resolve(packDir, "agents");
     ensureDir(outAgentsDir);
     const files = listFiles(subagentsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join2(outAgentsDir, basename(file));
+      const dest = join3(outAgentsDir, basename2(file));
       copyFileSync(file, dest);
       filesImported.push(dest);
     }
   }
   const skillsDir = resolve(rulesyncDir, "skills");
-  if (existsSync2(skillsDir)) {
+  if (existsSync3(skillsDir)) {
     const outSkillsDir = resolve(packDir, "skills");
     ensureDir(outSkillsDir);
     const skillDirs = listDirs(skillsDir);
     for (const skillDir of skillDirs) {
-      const skillName = basename(skillDir);
+      const skillName = basename2(skillDir);
       if (skillName.startsWith("."))
         continue;
-      const skillMd = join2(skillDir, "SKILL.md");
-      if (existsSync2(skillMd)) {
-        const outSkillDir = join2(outSkillsDir, skillName);
+      const skillMd = join3(skillDir, "SKILL.md");
+      if (existsSync3(skillMd)) {
+        const outSkillDir = join3(outSkillsDir, skillName);
         ensureDir(outSkillDir);
-        copyFileSync(skillMd, join2(outSkillDir, "SKILL.md"));
-        filesImported.push(join2(outSkillDir, "SKILL.md"));
+        const rawSkill = readFileSync3(skillMd, "utf-8");
+        const normalized = normalizeImportedSkillMarkdown(rawSkill, skillName);
+        const dest = join3(outSkillDir, "SKILL.md");
+        writeFileSync2(dest, normalized.content);
+        filesImported.push(dest);
+        if (normalized.addedDescription) {
+          warnings.push(`skills/${skillName}/SKILL.md missing description; added import placeholder.`);
+        }
       }
     }
   }
   const hooksJson = resolve(rulesyncDir, "hooks.json");
-  if (existsSync2(hooksJson)) {
+  if (existsSync3(hooksJson)) {
     const outHooksDir = resolve(packDir, "hooks");
     ensureDir(outHooksDir);
-    copyFileSync(hooksJson, join2(outHooksDir, "hooks.json"));
-    filesImported.push(join2(outHooksDir, "hooks.json"));
+    copyFileSync(hooksJson, join3(outHooksDir, "hooks.json"));
+    filesImported.push(join3(outHooksDir, "hooks.json"));
   }
   const mcpJson = resolve(rulesyncDir, "mcp.json");
-  if (existsSync2(mcpJson)) {
-    copyFileSync(mcpJson, join2(packDir, "mcp.json"));
-    filesImported.push(join2(packDir, "mcp.json"));
+  if (existsSync3(mcpJson)) {
+    copyFileSync(mcpJson, join3(packDir, "mcp.json"));
+    filesImported.push(join3(packDir, "mcp.json"));
   }
   const aiIgnore = resolve(rulesyncDir, ".aiignore");
   const rulesyncIgnore = resolve(projectRoot, ".rulesyncignore");
-  if (existsSync2(aiIgnore)) {
-    copyFileSync(aiIgnore, join2(packDir, "ignore"));
-    filesImported.push(join2(packDir, "ignore"));
-  } else if (existsSync2(rulesyncIgnore)) {
-    copyFileSync(rulesyncIgnore, join2(packDir, "ignore"));
-    filesImported.push(join2(packDir, "ignore"));
+  if (existsSync3(aiIgnore)) {
+    copyFileSync(aiIgnore, join3(packDir, "ignore"));
+    filesImported.push(join3(packDir, "ignore"));
+  } else if (existsSync3(rulesyncIgnore)) {
+    copyFileSync(rulesyncIgnore, join3(packDir, "ignore"));
+    filesImported.push(join3(packDir, "ignore"));
   }
   const packJson = {
     name: "default",
@@ -229,12 +325,12 @@ function importFromRulesync(projectRoot, outputPackDir) {
     targets: "*",
     features: "*"
   };
-  writeFileSync2(join2(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
+  writeFileSync2(join3(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
 `);
-  filesImported.push(join2(packDir, "pack.json"));
+  filesImported.push(join3(packDir, "pack.json"));
   let configGenerated = false;
   const rulesyncConfig = resolve(projectRoot, "rulesync.jsonc");
-  if (existsSync2(rulesyncConfig)) {
+  if (existsSync3(rulesyncConfig)) {
     const agentpacksConfig = convertRulesyncConfig(rulesyncConfig, packDir);
     const configPath = resolve(projectRoot, "agentpacks.jsonc");
     writeFileSync2(configPath, agentpacksConfig);
@@ -243,14 +339,14 @@ function importFromRulesync(projectRoot, outputPackDir) {
   return { packDir, filesImported, warnings, configGenerated };
 }
 function convertRulesyncConfig(rulesyncPath, _packDir) {
-  const raw = readFileSync2(rulesyncPath, "utf-8");
+  const raw = readFileSync3(rulesyncPath, "utf-8");
   const parsed = parseJsonc(raw);
   const targets = parsed.targets ?? ["opencode", "cursor", "claudecode"];
   const features = parsed.features ?? ["*"];
   const baseDirs = parsed.baseDirs ?? ["."];
   const global = parsed.global ?? false;
   const deleteVal = parsed.delete ?? true;
-  const relPackDir = "./" + join2("packs", "default");
+  const relPackDir = "./" + join3("packs", "default");
   const config = {
     $schema: "https://unpkg.com/agentpacks/schema.json",
     packs: [relPackDir],
@@ -267,13 +363,13 @@ function convertRulesyncConfig(rulesyncPath, _packDir) {
 }
 
 // src/importers/cursor.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, copyFileSync as copyFileSync2 } from "fs";
-import { resolve as resolve2, join as join3, basename as basename2 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3, copyFileSync as copyFileSync2 } from "fs";
+import { resolve as resolve2, join as join4, basename as basename3 } from "path";
 function importFromCursor(projectRoot, outputPackDir) {
   const cursorDir = resolve2(projectRoot, ".cursor");
   const warnings = [];
   const filesImported = [];
-  if (!existsSync3(cursorDir)) {
+  if (!existsSync4(cursorDir)) {
     return {
       packDir: "",
       filesImported: [],
@@ -284,12 +380,12 @@ function importFromCursor(projectRoot, outputPackDir) {
   const packDir = outputPackDir ?? resolve2(projectRoot, "packs", "cursor-import");
   ensureDir(packDir);
   const rulesDir = resolve2(cursorDir, "rules");
-  if (existsSync3(rulesDir)) {
+  if (existsSync4(rulesDir)) {
     const outRulesDir = resolve2(packDir, "rules");
     ensureDir(outRulesDir);
     const files = listFiles(rulesDir, { extension: ".mdc" });
     for (const file of files) {
-      const raw = readFileSync3(file, "utf-8");
+      const raw = readFileSync4(file, "utf-8");
       const { data, content } = parseFrontmatter(raw);
       const meta = {};
       if (data.description)
@@ -300,65 +396,71 @@ function importFromCursor(projectRoot, outputPackDir) {
         meta.globs = data.globs;
       meta.cursor = { ...data };
       const mdContent = buildAgentpacksRule(meta, content);
-      const name = basename2(file, ".mdc");
-      const dest = join3(outRulesDir, `${name}.md`);
+      const name = basename3(file, ".mdc");
+      const dest = join4(outRulesDir, `${name}.md`);
       writeFileSync3(dest, mdContent);
       filesImported.push(dest);
     }
     const mdFiles = listFiles(rulesDir, { extension: ".md" });
     for (const file of mdFiles) {
-      const dest = join3(outRulesDir, basename2(file));
+      const dest = join4(outRulesDir, basename3(file));
       copyFileSync2(file, dest);
       filesImported.push(dest);
     }
   }
   const agentsDir = resolve2(cursorDir, "agents");
-  if (existsSync3(agentsDir)) {
+  if (existsSync4(agentsDir)) {
     const outDir = resolve2(packDir, "agents");
     ensureDir(outDir);
     const files = listFiles(agentsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join3(outDir, basename2(file));
+      const dest = join4(outDir, basename3(file));
       copyFileSync2(file, dest);
       filesImported.push(dest);
     }
   }
   const skillsDir = resolve2(cursorDir, "skills");
-  if (existsSync3(skillsDir)) {
+  if (existsSync4(skillsDir)) {
     const outDir = resolve2(packDir, "skills");
     ensureDir(outDir);
     const dirs = listDirs(skillsDir);
     for (const dir of dirs) {
-      const name = basename2(dir);
-      const skillMd = join3(dir, "SKILL.md");
-      if (existsSync3(skillMd)) {
-        const outSkillDir = join3(outDir, name);
+      const name = basename3(dir);
+      const skillMd = join4(dir, "SKILL.md");
+      if (existsSync4(skillMd)) {
+        const outSkillDir = join4(outDir, name);
         ensureDir(outSkillDir);
-        copyFileSync2(skillMd, join3(outSkillDir, "SKILL.md"));
-        filesImported.push(join3(outSkillDir, "SKILL.md"));
+        const rawSkill = readFileSync4(skillMd, "utf-8");
+        const normalized = normalizeImportedSkillMarkdown(rawSkill, name);
+        const dest = join4(outSkillDir, "SKILL.md");
+        writeFileSync3(dest, normalized.content);
+        filesImported.push(dest);
+        if (normalized.addedDescription) {
+          warnings.push(`skills/${name}/SKILL.md missing description; added import placeholder.`);
+        }
       }
     }
   }
   const commandsDir = resolve2(cursorDir, "commands");
-  if (existsSync3(commandsDir)) {
+  if (existsSync4(commandsDir)) {
     const outDir = resolve2(packDir, "commands");
     ensureDir(outDir);
     const files = listFiles(commandsDir, { extension: ".md" });
     for (const file of files) {
-      const dest = join3(outDir, basename2(file));
+      const dest = join4(outDir, basename3(file));
       copyFileSync2(file, dest);
       filesImported.push(dest);
     }
   }
   const mcpJson = resolve2(cursorDir, "mcp.json");
-  if (existsSync3(mcpJson)) {
-    copyFileSync2(mcpJson, join3(packDir, "mcp.json"));
-    filesImported.push(join3(packDir, "mcp.json"));
+  if (existsSync4(mcpJson)) {
+    copyFileSync2(mcpJson, join4(packDir, "mcp.json"));
+    filesImported.push(join4(packDir, "mcp.json"));
   }
   const cursorIgnore = resolve2(projectRoot, ".cursorignore");
-  if (existsSync3(cursorIgnore)) {
-    copyFileSync2(cursorIgnore, join3(packDir, "ignore"));
-    filesImported.push(join3(packDir, "ignore"));
+  if (existsSync4(cursorIgnore)) {
+    copyFileSync2(cursorIgnore, join4(packDir, "ignore"));
+    filesImported.push(join4(packDir, "ignore"));
   }
   writePackJson(packDir, "cursor-import", filesImported);
   return { packDir, filesImported, warnings, configGenerated: false };
@@ -387,21 +489,21 @@ function writePackJson(packDir, name, filesImported) {
     targets: "*",
     features: "*"
   };
-  const dest = join3(packDir, "pack.json");
+  const dest = join4(packDir, "pack.json");
   writeFileSync3(dest, JSON.stringify(packJson, null, 2) + `
 `);
   filesImported.push(dest);
 }
 
 // src/importers/claude-code.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, copyFileSync as copyFileSync3 } from "fs";
-import { resolve as resolve3, join as join4, basename as basename3 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4, copyFileSync as copyFileSync3 } from "fs";
+import { resolve as resolve3, join as join5, basename as basename4 } from "path";
 function importFromClaudeCode(projectRoot, outputPackDir) {
   const warnings = [];
   const filesImported = [];
   const claudeDir = resolve3(projectRoot, ".claude");
-  const hasClaudeMd = existsSync4(resolve3(projectRoot, "CLAUDE.md"));
-  const hasClaudeDir = existsSync4(claudeDir);
+  const hasClaudeMd = existsSync5(resolve3(projectRoot, "CLAUDE.md"));
+  const hasClaudeDir = existsSync5(claudeDir);
   if (!hasClaudeMd && !hasClaudeDir) {
     return {
       packDir: "",
@@ -415,7 +517,7 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
   const rulesDir = resolve3(packDir, "rules");
   ensureDir(rulesDir);
   if (hasClaudeMd) {
-    const raw = readFileSync4(resolve3(projectRoot, "CLAUDE.md"), "utf-8");
+    const raw = readFileSync5(resolve3(projectRoot, "CLAUDE.md"), "utf-8");
     const ruleContent = [
       "---",
       "root: true",
@@ -425,29 +527,29 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
       raw
     ].join(`
 `);
-    const dest = join4(rulesDir, "claude-root.md");
+    const dest = join5(rulesDir, "claude-root.md");
     writeFileSync4(dest, ruleContent);
     filesImported.push(dest);
   }
   if (hasClaudeDir) {
     const claudeRulesDir = resolve3(claudeDir, "rules");
-    if (existsSync4(claudeRulesDir)) {
+    if (existsSync5(claudeRulesDir)) {
       const files = listFiles(claudeRulesDir, { extension: ".md" });
       for (const file of files) {
-        const dest = join4(rulesDir, basename3(file));
+        const dest = join5(rulesDir, basename4(file));
         copyFileSync3(file, dest);
         filesImported.push(dest);
       }
     }
     const settingsPath = resolve3(claudeDir, "settings.json");
-    if (existsSync4(settingsPath)) {
+    if (existsSync5(settingsPath)) {
       try {
-        const raw = readFileSync4(settingsPath, "utf-8");
+        const raw = readFileSync5(settingsPath, "utf-8");
         const settings = JSON.parse(raw);
         const mcpServers = settings.mcpServers ?? settings.mcp_servers;
         if (mcpServers && typeof mcpServers === "object") {
           const mcpConfig = { servers: mcpServers };
-          const dest = join4(packDir, "mcp.json");
+          const dest = join5(packDir, "mcp.json");
           writeFileSync4(dest, JSON.stringify(mcpConfig, null, 2) + `
 `);
           filesImported.push(dest);
@@ -467,7 +569,7 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
     targets: "*",
     features: "*"
   };
-  const packJsonPath = join4(packDir, "pack.json");
+  const packJsonPath = join5(packDir, "pack.json");
   writeFileSync4(packJsonPath, JSON.stringify(packJson, null, 2) + `
 `);
   filesImported.push(packJsonPath);
@@ -475,13 +577,13 @@ function importFromClaudeCode(projectRoot, outputPackDir) {
 }
 
 // src/importers/opencode.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5, copyFileSync as copyFileSync4 } from "fs";
-import { resolve as resolve4, join as join5, basename as basename4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, copyFileSync as copyFileSync4 } from "fs";
+import { resolve as resolve4, join as join6, basename as basename5 } from "path";
 function importFromOpenCode(projectRoot, outputPackDir) {
   const warnings = [];
   const filesImported = [];
   const ocDir = resolve4(projectRoot, ".opencode");
-  if (!existsSync5(ocDir)) {
+  if (!existsSync6(ocDir)) {
     return {
       packDir: "",
       filesImported: [],
@@ -495,41 +597,47 @@ function importFromOpenCode(projectRoot, outputPackDir) {
   importDirMd(resolve4(ocDir, "commands"), resolve4(packDir, "commands"), filesImported);
   importDirMd(resolve4(ocDir, "agents"), resolve4(packDir, "agents"), filesImported);
   const skillDir = resolve4(ocDir, "skill");
-  if (existsSync5(skillDir)) {
+  if (existsSync6(skillDir)) {
     const outSkillDir = resolve4(packDir, "skills");
     ensureDir(outSkillDir);
     const dirs = listDirs(skillDir);
     for (const dir of dirs) {
-      const name = basename4(dir);
+      const name = basename5(dir);
       if (name.startsWith("."))
         continue;
-      const skillMd = join5(dir, "SKILL.md");
-      if (existsSync5(skillMd)) {
-        const outDir = join5(outSkillDir, name);
+      const skillMd = join6(dir, "SKILL.md");
+      if (existsSync6(skillMd)) {
+        const outDir = join6(outSkillDir, name);
         ensureDir(outDir);
-        copyFileSync4(skillMd, join5(outDir, "SKILL.md"));
-        filesImported.push(join5(outDir, "SKILL.md"));
+        const rawSkill = readFileSync6(skillMd, "utf-8");
+        const normalized = normalizeImportedSkillMarkdown(rawSkill, name);
+        const dest2 = join6(outDir, "SKILL.md");
+        writeFileSync5(dest2, normalized.content);
+        filesImported.push(dest2);
+        if (normalized.addedDescription) {
+          warnings.push(`skills/${name}/SKILL.md missing description; added import placeholder.`);
+        }
       }
     }
   }
   const pluginsDir = resolve4(ocDir, "plugins");
-  if (existsSync5(pluginsDir)) {
+  if (existsSync6(pluginsDir)) {
     const outPluginsDir = resolve4(packDir, "plugins");
     ensureDir(outPluginsDir);
     const files = listFiles(pluginsDir);
     for (const file of files) {
       if (file.endsWith(".ts") || file.endsWith(".js")) {
-        const dest2 = join5(outPluginsDir, basename4(file));
+        const dest2 = join6(outPluginsDir, basename5(file));
         copyFileSync4(file, dest2);
         filesImported.push(dest2);
       }
     }
   }
   const agentsMd = resolve4(projectRoot, "AGENTS.md");
-  if (existsSync5(agentsMd)) {
+  if (existsSync6(agentsMd)) {
     const outRulesDir = resolve4(packDir, "rules");
     ensureDir(outRulesDir);
-    const raw = readFileSync5(agentsMd, "utf-8");
+    const raw = readFileSync6(agentsMd, "utf-8");
     const ruleContent = [
       "---",
       "root: true",
@@ -539,18 +647,18 @@ function importFromOpenCode(projectRoot, outputPackDir) {
       raw
     ].join(`
 `);
-    const dest2 = join5(outRulesDir, "agents-md-root.md");
+    const dest2 = join6(outRulesDir, "agents-md-root.md");
     writeFileSync5(dest2, ruleContent);
     filesImported.push(dest2);
   }
   const ocJson = resolve4(projectRoot, "opencode.json");
-  if (existsSync5(ocJson)) {
+  if (existsSync6(ocJson)) {
     try {
-      const raw = readFileSync5(ocJson, "utf-8");
+      const raw = readFileSync6(ocJson, "utf-8");
       const config = JSON.parse(raw);
       const mcpObj = config.mcp;
       if (mcpObj) {
-        const dest2 = join5(packDir, "mcp.json");
+        const dest2 = join6(packDir, "mcp.json");
         writeFileSync5(dest2, JSON.stringify({ servers: mcpObj }, null, 2) + `
 `);
         filesImported.push(dest2);
@@ -560,9 +668,9 @@ function importFromOpenCode(projectRoot, outputPackDir) {
     }
   }
   const ocIgnore = resolve4(projectRoot, ".opencodeignore");
-  if (existsSync5(ocIgnore)) {
-    copyFileSync4(ocIgnore, join5(packDir, "ignore"));
-    filesImported.push(join5(packDir, "ignore"));
+  if (existsSync6(ocIgnore)) {
+    copyFileSync4(ocIgnore, join6(packDir, "ignore"));
+    filesImported.push(join6(packDir, "ignore"));
   }
   const packJson = {
     name: "opencode-import",
@@ -574,19 +682,19 @@ function importFromOpenCode(projectRoot, outputPackDir) {
     targets: "*",
     features: "*"
   };
-  const dest = join5(packDir, "pack.json");
+  const dest = join6(packDir, "pack.json");
   writeFileSync5(dest, JSON.stringify(packJson, null, 2) + `
 `);
   filesImported.push(dest);
   return { packDir, filesImported, warnings, configGenerated: false };
 }
 function importDirMd(srcDir, outDir, filesImported) {
-  if (!existsSync5(srcDir))
+  if (!existsSync6(srcDir))
     return;
   ensureDir(outDir);
   const files = listFiles(srcDir, { extension: ".md" });
   for (const file of files) {
-    const dest = join5(outDir, basename4(file));
+    const dest = join6(outDir, basename5(file));
     copyFileSync4(file, dest);
     filesImported.push(dest);
   }

package/dist/node/cli/install.js

@@ -11,6 +11,7 @@ var TARGET_IDS = [
   "cursor",
   "claudecode",
   "codexcli",
+  "mistralvibe",
   "geminicli",
   "copilot",
   "agentsmd",

package/dist/node/cli/models-explain.js

@@ -11,6 +11,7 @@ var TARGET_IDS = [
   "cursor",
   "claudecode",
   "codexcli",
+  "mistralvibe",
   "geminicli",
   "copilot",
   "agentsmd",
@@ -351,6 +352,8 @@ function agentMatchesTarget(agent, targetId) {
 // src/features/skills.ts
 import { readFileSync as readFileSync6, existsSync as existsSync3 } from "fs";
 import { basename as basename4, join as join2 } from "path";
+var SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SKILL_NAME_MAX_LENGTH = 64;
 function parseSkills(skillsDir, packName) {
   const dirs = listDirs(skillsDir);
   const skills = [];
@@ -374,6 +377,59 @@ function parseSkillFile(filepath, skillDir, packName) {
     content
   };
 }
+function buildSkillFrontmatter(skill) {
+  return {
+    ...skill.meta,
+    name: skill.name
+  };
+}
+function serializeSkill(skill) {
+  return serializeFrontmatter(buildSkillFrontmatter(skill), skill.content);
+}
+function normalizeImportedSkillMarkdown(source, skillName) {
+  const { data, content } = parseFrontmatter(source);
+  const normalized = {
+    ...data,
+    name: skillName
+  };
+  let addedDescription = false;
+  const description = normalized.description;
+  if (typeof description !== "string" || description.trim().length === 0) {
+    normalized.description = `Imported skill: ${skillName}`;
+    addedDescription = true;
+  }
+  return {
+    content: serializeFrontmatter(normalized, content),
+    addedDescription
+  };
+}
+function validateAgentSkillsFrontmatter(skill) {
+  const errors = [];
+  const dirName = basename4(skill.sourceDir);
+  const declaredName = skill.meta.name;
+  if (typeof declaredName !== "string" || declaredName.trim().length === 0) {
+    errors.push('Missing required frontmatter field "name".');
+  } else {
+    if (declaredName.length > SKILL_NAME_MAX_LENGTH) {
+      errors.push(`Invalid "name": must be at most ${SKILL_NAME_MAX_LENGTH} characters.`);
+    }
+    if (!SKILL_NAME_PATTERN.test(declaredName)) {
+      errors.push('Invalid "name": use lowercase letters, numbers, and single hyphens only.');
+    }
+    if (declaredName !== dirName) {
+      errors.push(`Invalid "name": must match containing directory "${dirName}".`);
+    }
+  }
+  const description = skill.meta.description;
+  if (typeof description !== "string" || description.trim().length === 0) {
+    errors.push('Missing required frontmatter field "description".');
+  }
+  const allowedTools = skill.meta["allowed-tools"];
+  if (allowedTools !== undefined && (!Array.isArray(allowedTools) || allowedTools.some((tool) => typeof tool !== "string" || tool.length === 0))) {
+    errors.push('Invalid "allowed-tools": expected an array of non-empty strings.');
+  }
+  return errors;
+}
 function skillMatchesTarget(skill, targetId) {
   const { targets } = skill.meta;
   if (!targets || targets === "*")