@agents-inc/cli 0.47.0 → 0.48.0

package/dist/{chunk-GFDGYQ6M.js → chunk-P2SFRDWI.js}

@@ -34,19 +34,20 @@ import {
   readFileOptional,
   readFileSafe,
   remove,
+  skillCategoriesFileSchema,
   skillDisplayNameSchema,
   skillFrontmatterLoaderSchema,
   skillFrontmatterValidationSchema,
   skillIdSchema,
   skillMetadataLoaderSchema,
-  skillsMatrixConfigSchema,
+  skillRulesFileSchema,
   stacksConfigSchema,
   validateNestingDepth,
   verbose,
   warn,
   warnUnknownFields,
   writeFile
-} from "./chunk-C4QI54PN.js";
+} from "./chunk-YMUWTPOM.js";
 import {
   ARCHIVED_SKILLS_DIR_NAME,
   CACHE_DIR,
@@ -74,13 +75,14 @@ import {
   PROJECT_ROOT,
   SCHEMA_PATHS,
   SKILLS_DIR_PATH,
-  SKILLS_MATRIX_PATH,
+  SKILL_CATEGORIES_YAML_PATH,
+  SKILL_RULES_YAML_PATH,
   STACKS_FILE_PATH,
   STANDARD_DIRS,
   STANDARD_FILES,
   YAML_FORMATTING,
   yamlSchemaComment
-} from "./chunk-FTD5Z6QD.js";
+} from "./chunk-LESHL6SM.js";
 import {
   init_esm_shims
 } from "./chunk-DHET7RCE.js";
@@ -1165,7 +1167,7 @@ import { unique as unique4 } from "remeda";
 // src/cli/lib/metadata-keys.ts
 init_esm_shims();
 var METADATA_KEYS = {
-  CLI_NAME: "cliName",
+  DISPLAY_NAME: "displayName",
   CLI_DESCRIPTION: "cliDescription",
   CATEGORY: "category",
   FORKED_FROM: "forkedFrom",
@@ -2225,7 +2227,8 @@ var PATH_OVERRIDES_COMMENT = [
   `# skillsDir: ${SKILLS_DIR_PATH}`,
   `# agentsDir: ${DIRS.agents}`,
   `# stacksFile: ${STACKS_FILE_PATH}`,
-  `# matrixFile: ${SKILLS_MATRIX_PATH}`,
+  `# categoriesFile: ${SKILL_CATEGORIES_YAML_PATH}`,
+  `# rulesFile: ${SKILL_RULES_YAML_PATH}`,
   ""
 ].join("\n");
 async function writeConfigFile(config, configPath) {
@@ -3138,34 +3141,56 @@ import path19 from "path";
 import { z as z3 } from "zod";
 var rawMetadataSchema = z3.object({
   category: categoryPathSchema,
-  categoryExclusive: z3.boolean().optional(),
   author: z3.string(),
-  cliName: z3.string().optional(),
+  displayName: z3.string().optional(),
   cliDescription: z3.string().optional(),
   usageGuidance: z3.string().optional(),
   tags: z3.array(z3.string()).optional(),
-  // Lenient: accepts display names and skill IDs from YAML, resolved to canonical IDs during matrix merge
-  compatibleWith: z3.array(z3.string()).optional(),
-  conflictsWith: z3.array(z3.string()).optional(),
-  requires: z3.array(z3.string()).optional(),
-  requiresSetup: z3.array(z3.string()).optional(),
-  providesSetupFor: z3.array(z3.string()).optional(),
   domain: extensibleDomainSchema.optional(),
   custom: z3.boolean().optional()
 });
-async function loadSkillsMatrix(configPath) {
+var KNOWN_DOMAINS = new Set(DOMAIN_VALUES);
+var AUTO_SYNTH_ORDER = 999;
+function synthesizeCategory(categoryPath, skillDomain) {
+  const prefix = categoryPath.split("-")[0];
+  const domain = skillDomain ?? (KNOWN_DOMAINS.has(prefix) ? prefix : void 0);
+  const displayName = categoryPath.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return {
+    id: categoryPath,
+    displayName,
+    description: `Auto-generated category for ${categoryPath}`,
+    domain,
+    exclusive: true,
+    required: false,
+    order: AUTO_SYNTH_ORDER,
+    custom: true
+  };
+}
+async function loadSkillCategories(configPath) {
+  const content = await readFile(configPath);
+  const raw = parseYaml7(content);
+  const result = skillCategoriesFileSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(
+      `Invalid skill categories at '${configPath}': ${formatZodErrors(result.error.issues)}`
+    );
+  }
+  verbose(`Loaded skill categories: ${configPath}`);
+  return result.data.categories;
+}
+async function loadSkillRules(configPath) {
   const content = await readFile(configPath);
   const raw = parseYaml7(content);
-  const result = skillsMatrixConfigSchema.safeParse(raw);
+  const result = skillRulesFileSchema.safeParse(raw);
   if (!result.success) {
     throw new Error(
-      `Invalid skills matrix at '${configPath}': ${formatZodErrors(result.error.issues)}`
+      `Invalid skill rules at '${configPath}': ${formatZodErrors(result.error.issues)}`
     );
   }
   const data = result.data;
-  const matrix = {
+  const config = {
     version: data.version,
-    categories: data.categories,
+    aliases: data.aliases ?? {},
     relationships: data.relationships ?? {
       conflicts: [],
       discourages: [],
@@ -3173,10 +3198,10 @@ async function loadSkillsMatrix(configPath) {
       requires: [],
       alternatives: []
     },
-    skillAliases: data.skillAliases ?? {}
+    perSkill: data["per-skill"] ?? {}
   };
-  verbose(`Loaded skills matrix: ${configPath}`);
-  return matrix;
+  verbose(`Loaded skill rules: ${configPath}`);
+  return config;
 }
 async function extractAllSkills(skillsDir) {
   const skills = [];
@@ -3205,9 +3230,9 @@ async function extractAllSkills(skillsDir) {
       verbose(`Skipping ${metadataFile}: Invalid SKILL.md frontmatter`);
       continue;
     }
-    if (!metadata.cliName) {
+    if (!metadata.displayName) {
       throw new Error(
-        `Skill at ${metadataFile} is missing required '${METADATA_KEYS.CLI_NAME}' field in metadata.yaml`
+        `Skill at ${metadataFile} is missing required '${METADATA_KEYS.DISPLAY_NAME}' field in metadata.yaml`
       );
     }
     const skillId = frontmatter.name;
@@ -3217,14 +3242,8 @@ async function extractAllSkills(skillsDir) {
       description: metadata.cliDescription || frontmatter.description,
       usageGuidance: metadata.usageGuidance,
       category: metadata.category,
-      categoryExclusive: metadata.categoryExclusive ?? true,
       author: metadata.author,
       tags: metadata.tags ?? [],
-      compatibleWith: metadata.compatibleWith ?? [],
-      conflictsWith: metadata.conflictsWith ?? [],
-      requires: metadata.requires ?? [],
-      requiresSetup: metadata.requiresSetup ?? [],
-      providesSetupFor: metadata.providesSetupFor ?? [],
       path: `skills/${skillDir}/`,
       ...metadata.domain ? { domain: metadata.domain } : {},
       ...metadata.custom === true ? { custom: true } : {}
@@ -3271,25 +3290,36 @@ function resolveToCanonicalId(nameOrId, displayNameToId, directoryPathToId = {},
   }
   return nameOrId;
 }
-async function mergeMatrixWithSkills(matrix, skills) {
-  const displayNameToId = matrix.skillAliases;
+async function mergeMatrixWithSkills(categories, relationships, aliases, skills, perSkillRules) {
+  const displayNameToId = aliases;
   const displayNames = buildReverseDisplayNames(displayNameToId);
   const directoryPathToId = buildDirectoryPathToIdMap(skills);
   const resolvedSkills = {};
   for (const skill of skills) {
     const resolved = buildResolvedSkill(
       skill,
-      matrix,
+      categories,
+      relationships,
       displayNameToId,
       displayNames,
-      directoryPathToId
+      directoryPathToId,
+      perSkillRules
     );
     resolvedSkills[skill.id] = resolved;
   }
+  const synthesizedCategories = { ...categories };
+  for (const skill of skills) {
+    const subcategory = skill.category;
+    if (!synthesizedCategories[subcategory]) {
+      const synthesized = synthesizeCategory(skill.category, skill.domain);
+      synthesizedCategories[subcategory] = synthesized;
+      verbose(`Auto-synthesized category '${skill.category}' for skill '${skill.id}'`);
+    }
+  }
   const suggestedStacks = resolveSuggestedStacks();
   const merged = {
-    version: matrix.version,
-    categories: matrix.categories,
+    version: "1.0.0",
+    categories: synthesizedCategories,
     skills: resolvedSkills,
     suggestedStacks,
     displayNameToId,
@@ -3382,41 +3412,48 @@ function resolveDiscourages(skillId, discourageRules, resolve) {
   }
   return discourages;
 }
-function buildResolvedSkill(skill, matrix, displayNameToId, displayNames, directoryPathToId) {
+function buildResolvedSkill(skill, _categories, relationships, displayNameToId, displayNames, directoryPathToId, perSkillRules) {
   const resolve = (id, context) => resolveToCanonicalId(
     id,
     displayNameToId,
     directoryPathToId,
     context ? `${skill.id} ${context}` : void 0
   );
-  const { relationships } = matrix;
+  const skillAlias = displayNames[skill.id];
+  const perSkill = skillAlias ? perSkillRules?.[skillAlias] : void 0;
   return {
     id: skill.id,
     displayName: displayNames[skill.id],
     description: skill.description,
     usageGuidance: skill.usageGuidance,
     category: skill.category,
-    categoryExclusive: skill.categoryExclusive,
     tags: skill.tags,
     author: skill.author,
     conflictsWith: resolveConflicts(
       skill.id,
-      skill.conflictsWith,
+      perSkill?.conflictsWith ?? [],
       relationships.conflicts,
       resolve
     ),
     recommends: resolveRecommends(
       skill.id,
-      skill.compatibleWith,
+      perSkill?.compatibleWith ?? [],
       relationships.recommends,
       resolve
     ),
-    requires: resolveRequirements(skill.id, skill.requires, relationships.requires, resolve),
+    requires: resolveRequirements(
+      skill.id,
+      perSkill?.requires ?? [],
+      relationships.requires,
+      resolve
+    ),
     alternatives: resolveAlternatives(skill.id, relationships.alternatives, resolve),
     discourages: resolveDiscourages(skill.id, relationships.discourages, resolve),
-    compatibleWith: skill.compatibleWith.map((id) => resolve(id, "compatibleWith")),
-    requiresSetup: skill.requiresSetup.map((id) => resolve(id, "requiresSetup")),
-    providesSetupFor: skill.providesSetupFor.map((id) => resolve(id, "providesSetupFor")),
+    compatibleWith: (perSkill?.compatibleWith ?? []).map((id) => resolve(id, "compatibleWith")),
+    requiresSetup: (perSkill?.requiresSetup ?? []).map((id) => resolve(id, "requiresSetup")),
+    providesSetupFor: (perSkill?.providesSetupFor ?? []).map(
+      (id) => resolve(id, "providesSetupFor")
+    ),
     path: skill.path
   };
 }
@@ -3768,12 +3805,15 @@ function checkSubcategoryDomains(matrix, issues) {
 function checkSkillCategories(matrix, issues) {
   for (const [skillId, skill] of typedEntries(matrix.skills)) {
     if (!skill) continue;
-    if (!matrix.categories[skill.category]) {
+    const category = matrix.categories[skill.category];
+    if (!category) {
       issues.push({
         severity: "warning",
         finding: "skill-unknown-category",
         details: `Skill '${skillId}' references category '${skill.category}' which does not exist in the matrix`
       });
+    } else if (category.custom) {
+      verbose(`Skill '${skillId}' uses auto-synthesized category '${skill.category}'`);
     }
   }
 }
@@ -4088,47 +4128,62 @@ async function loadFromRemote(source, sourceConfig, forceRefresh) {
 }
 async function loadAndMergeFromBasePath(basePath) {
   const sourceProjectConfig = await loadProjectSourceConfig(basePath);
-  const matrixRelPath = sourceProjectConfig?.matrixFile ?? SKILLS_MATRIX_PATH;
   const skillsDirRelPath = sourceProjectConfig?.skillsDir ?? SKILLS_DIR_PATH;
   const stacksRelFile = sourceProjectConfig?.stacksFile;
-  const cliMatrixPath = path21.join(PROJECT_ROOT, SKILLS_MATRIX_PATH);
-  const cliMatrix = await loadSkillsMatrix(cliMatrixPath);
-  let matrix = cliMatrix;
+  const cliCategoriesPath = path21.join(PROJECT_ROOT, SKILL_CATEGORIES_YAML_PATH);
+  const cliRulesPath = path21.join(PROJECT_ROOT, SKILL_RULES_YAML_PATH);
+  const cliCategories = await loadSkillCategories(cliCategoriesPath);
+  const cliRules = await loadSkillRules(cliRulesPath);
+  let categories = cliCategories;
+  let relationships = cliRules.relationships;
+  let aliases = cliRules.aliases;
+  let perSkillRules = cliRules.perSkill;
   await discoverAndExtendFromSource(basePath);
-  const sourceMatrixPath = path21.join(basePath, matrixRelPath);
-  if (await fileExists(sourceMatrixPath)) {
-    const sourceMatrix = await loadSkillsMatrix(sourceMatrixPath);
-    const mergedCategories = { ...cliMatrix.categories, ...sourceMatrix.categories };
-    const mergedRelationships = {
-      conflicts: [...cliMatrix.relationships.conflicts, ...sourceMatrix.relationships.conflicts],
-      discourages: [
-        ...cliMatrix.relationships.discourages,
-        ...sourceMatrix.relationships.discourages
-      ],
-      recommends: [...cliMatrix.relationships.recommends, ...sourceMatrix.relationships.recommends],
-      requires: [...cliMatrix.relationships.requires, ...sourceMatrix.relationships.requires],
-      alternatives: [
-        ...cliMatrix.relationships.alternatives,
-        ...sourceMatrix.relationships.alternatives
-      ]
-    };
-    const mergedAliases = { ...cliMatrix.skillAliases, ...sourceMatrix.skillAliases };
-    matrix = {
-      version: cliMatrix.version,
-      categories: mergedCategories,
-      relationships: mergedRelationships,
-      skillAliases: mergedAliases
-    };
-    verbose(
-      `Matrix merged: CLI (${typedKeys(cliMatrix.categories).length} categories) + source (${typedKeys(sourceMatrix.categories).length} categories)`
-    );
+  const sourceCategoriesPath = path21.join(basePath, SKILL_CATEGORIES_YAML_PATH);
+  const sourceRulesPath = path21.join(basePath, SKILL_RULES_YAML_PATH);
+  const hasSourceCategories = await fileExists(sourceCategoriesPath);
+  const hasSourceRules = await fileExists(sourceRulesPath);
+  if (hasSourceCategories || hasSourceRules) {
+    if (hasSourceCategories) {
+      const sourceCategories = await loadSkillCategories(sourceCategoriesPath);
+      categories = { ...cliCategories, ...sourceCategories };
+      verbose(
+        `Loaded source categories: ${sourceCategoriesPath} (${typedKeys(sourceCategories).length} categories)`
+      );
+    }
+    if (hasSourceRules) {
+      const sourceRules = await loadSkillRules(sourceRulesPath);
+      relationships = {
+        conflicts: [...cliRules.relationships.conflicts, ...sourceRules.relationships.conflicts],
+        discourages: [
+          ...cliRules.relationships.discourages,
+          ...sourceRules.relationships.discourages
+        ],
+        recommends: [...cliRules.relationships.recommends, ...sourceRules.relationships.recommends],
+        requires: [...cliRules.relationships.requires, ...sourceRules.relationships.requires],
+        alternatives: [
+          ...cliRules.relationships.alternatives,
+          ...sourceRules.relationships.alternatives
+        ]
+      };
+      aliases = { ...cliRules.aliases, ...sourceRules.aliases };
+      perSkillRules = { ...cliRules.perSkill, ...sourceRules.perSkill };
+      verbose(`Loaded source rules: ${sourceRulesPath}`);
+    }
+    verbose(`Matrix merged: CLI (${typedKeys(cliCategories).length} categories) + source`);
   } else {
-    verbose(`Matrix from CLI only (source has no matrix): ${cliMatrixPath}`);
+    verbose(`Matrix from CLI only (source has no categories/rules files)`);
   }
   const skillsDir = path21.join(basePath, skillsDirRelPath);
   verbose(`Skills from source: ${skillsDir}`);
   const skills = await extractAllSkills(skillsDir);
-  const mergedMatrix = await mergeMatrixWithSkills(matrix, skills);
+  const mergedMatrix = await mergeMatrixWithSkills(
+    categories,
+    relationships,
+    aliases,
+    skills,
+    perSkillRules
+  );
   const sourceStacks = await loadStacks(basePath, stacksRelFile);
   const stacks = sourceStacks.length > 0 ? sourceStacks : await loadStacks(PROJECT_ROOT);
   if (stacks.length > 0) {
@@ -4305,7 +4360,6 @@ function mergeLocalSkillsIntoMatrix(matrix, localResult) {
       description: metadata.description,
       usageGuidance: metadata.usageGuidance,
       category,
-      categoryExclusive: metadata.categoryExclusive,
       tags: metadata.tags ?? [],
       author: LOCAL_DEFAULTS.AUTHOR,
       conflictsWith: existingSkill?.conflictsWith ?? [],
@@ -4368,11 +4422,10 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
     return null;
   }
   const metadata = parsed.data;
-  if (!metadata.cliName) {
-    warn(
-      `Skipping local skill '${skillDirName}': missing required '${METADATA_KEYS.CLI_NAME}' in metadata.yaml`
+  if (!metadata.displayName) {
+    throw new Error(
+      `Local skill '${skillDirName}' is missing required '${METADATA_KEYS.DISPLAY_NAME}' field in metadata.yaml`
     );
-    return null;
   }
   const skillMdContent = await readFile(skillMdPath);
   const frontmatter = parseFrontmatter(skillMdContent, skillMdPath);
@@ -4394,14 +4447,8 @@ async function extractLocalSkill(localSkillsPath, skillDirName) {
     description: metadata.cliDescription || frontmatter.description,
     usageGuidance: metadata.usageGuidance,
     category,
-    categoryExclusive: metadata.categoryExclusive ?? false,
     author: LOCAL_DEFAULTS.AUTHOR,
     tags: metadata.tags ?? [],
-    compatibleWith: metadata.compatibleWith ?? [],
-    conflictsWith: metadata.conflictsWith ?? [],
-    requires: metadata.requires ?? [],
-    requiresSetup: metadata.requiresSetup ?? [],
-    providesSetupFor: metadata.providesSetupFor ?? [],
     path: relativePath,
     local: true,
     localPath: relativePath
@@ -4518,7 +4565,8 @@ export {
   printCompilationSummary,
   archiveLocalSkill,
   restoreArchivedSkill,
-  loadSkillsMatrix,
+  loadSkillCategories,
+  loadSkillRules,
   extractAllSkills,
   mergeMatrixWithSkills,
   resolveAlias,
@@ -4551,4 +4599,4 @@ export {
   validateAllPlugins,
   printPluginValidationResult
 };
-//# sourceMappingURL=chunk-GFDGYQ6M.js.map
+//# sourceMappingURL=chunk-P2SFRDWI.js.map