agentpacks 0.9.0 → 1.0.0

package/dist/node/importers/rulesync.js

@@ -111,15 +111,123 @@ function getHeader(type) {
   }
 }
 
+// src/utils/frontmatter.ts
+import matter from "gray-matter";
+function parseFrontmatter(source) {
+  const { data, content } = matter(source);
+  return {
+    data,
+    content: content.trim(),
+    raw: source
+  };
+}
+function serializeFrontmatter(data, content) {
+  const filtered = Object.fromEntries(Object.entries(data).filter(([, v]) => v !== undefined));
+  if (Object.keys(filtered).length === 0) {
+    return 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: [],
@@ -130,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",
@@ -211,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);
@@ -225,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],