@claude-collective/cli 0.21.0 → 0.25.1

package/dist/commands/validate.js

@@ -2,146 +2,95 @@
 import {
   BaseCommand,
   EXIT_CODES
-} from "../chunk-EHS3TWWP.js";
+} from "../chunk-OBXAY23Y.js";
 import {
-  directoryExists,
-  fileExists,
-  listDirectories,
-  readFile
-} from "../chunk-AL74GBW4.js";
+  extractFrontmatter,
+  printPluginValidationResult,
+  validateAllPlugins,
+  validatePlugin
+} from "../chunk-YDBSSAJ6.js";
 import {
-  PROJECT_ROOT
-} from "../chunk-FJFEKPXF.js";
+  agentYamlGenerationSchema,
+  fileExists,
+  metadataValidationSchema,
+  readFile,
+  skillFrontmatterValidationSchema,
+  skillsMatrixConfigSchema,
+  stackConfigValidationSchema
+} from "../chunk-ZDREFYD2.js";
+import "../chunk-HWD32NP7.js";
+import "../chunk-O6ZTD7ZI.js";
 import {
   init_esm_shims
-} from "../chunk-DHET7RCE.js";
+} from "../chunk-AWKZ5BDL.js";
 
 // src/cli/commands/validate.ts
 init_esm_shims();
 import { Args, Flags } from "@oclif/core";
-import path3 from "path";
+import path2 from "path";
 
 // src/cli/lib/schema-validator.ts
 init_esm_shims();
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
+import { sumBy } from "remeda";
 import path from "path";
-import { parse as parseYaml2 } from "yaml";
-import fg from "fast-glob";
-
-// src/cli/utils/frontmatter.ts
-init_esm_shims();
 import { parse as parseYaml } from "yaml";
-function extractFrontmatter(content) {
-  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/;
-  const match = content.match(frontmatterRegex);
-  if (!match || !match[1]) {
-    return null;
-  }
-  try {
-    return parseYaml(match[1]);
-  } catch {
-    return null;
-  }
-}
-
-// src/cli/lib/schema-validator.ts
+import fg from "fast-glob";
 var VALIDATION_TARGETS = [
   {
     name: "Skills Matrix",
-    schema: "skills-matrix.schema.json",
+    schema: skillsMatrixConfigSchema,
     pattern: "skills-matrix.yaml",
     baseDir: "src/config"
   },
   {
     name: "Skill Metadata",
-    schema: "metadata.schema.json",
+    schema: metadataValidationSchema,
     pattern: "**/metadata.yaml",
     baseDir: "src/skills"
   },
   {
     name: "Stack Skill Metadata",
-    schema: "metadata.schema.json",
+    schema: metadataValidationSchema,
     pattern: "**/skills/**/metadata.yaml",
     baseDir: "src/stacks"
   },
   {
     name: "Stack Config",
-    schema: "stack.schema.json",
+    schema: stackConfigValidationSchema,
     pattern: "*/config.yaml",
     baseDir: "src/stacks"
   },
   {
     name: "Agent Definition",
-    schema: "agent.schema.json",
+    schema: agentYamlGenerationSchema,
     pattern: "**/agent.yaml",
     baseDir: "src/agents"
   },
   {
     name: "Skill Frontmatter",
-    schema: "skill-frontmatter.schema.json",
+    schema: skillFrontmatterValidationSchema,
     pattern: "**/SKILL.md",
     baseDir: "src/skills",
     extractor: extractFrontmatter
   },
   {
     name: "Stack Skill Frontmatter",
-    schema: "skill-frontmatter.schema.json",
+    schema: skillFrontmatterValidationSchema,
     pattern: "**/skills/**/SKILL.md",
     baseDir: "src/stacks",
     extractor: extractFrontmatter
   }
 ];
-var schemaCache = /* @__PURE__ */ new Map();
-var validatorCache = /* @__PURE__ */ new Map();
-async function loadSchema(schemaName, rootDir = process.cwd()) {
-  const cacheKey = `${rootDir}:${schemaName}`;
-  if (schemaCache.has(cacheKey)) {
-    return schemaCache.get(cacheKey);
-  }
-  const locations = [
-    path.join(PROJECT_ROOT, "src", "schemas", schemaName),
-    path.join(rootDir, "src", "schemas", schemaName)
-  ];
-  for (const schemaPath of locations) {
-    if (await fileExists(schemaPath)) {
-      const content = await readFile(schemaPath);
-      const schema = JSON.parse(content);
-      schemaCache.set(cacheKey, schema);
-      return schema;
+function formatZodErrors(error) {
+  return error.issues.map((issue) => {
+    const path3 = issue.path.join(".");
+    if (issue.code === "unrecognized_keys") {
+      return `Unrecognized key: "${issue.keys.join('", "')}"`;
     }
-  }
-  throw new Error(`Schema not found: ${schemaName}. Searched: ${locations.join(", ")}`);
-}
-async function getValidator(schemaName, rootDir = process.cwd()) {
-  const cacheKey = `${rootDir}:${schemaName}`;
-  if (validatorCache.has(cacheKey)) {
-    return validatorCache.get(cacheKey);
-  }
-  const ajv = new Ajv({ allErrors: true, strict: false });
-  addFormats(ajv);
-  const schema = await loadSchema(schemaName, rootDir);
-  const validate = ajv.compile(schema);
-  validatorCache.set(cacheKey, validate);
-  return validate;
-}
-function formatAjvErrors(errors) {
-  if (!errors) return [];
-  return errors.map((err) => {
-    const errorPath = err.instancePath ? err.instancePath.replace(/^\//, "").replace(/\//g, ".") : "";
-    const message = err.message || "Unknown error";
-    if (err.keyword === "additionalProperties") {
-      const prop = err.params.additionalProperty;
-      return `Unrecognized key: "${prop}"`;
-    }
-    if (err.keyword === "enum") {
-      const allowed = err.params.allowedValues;
-      return errorPath ? `${errorPath}: ${message}. Allowed: ${allowed?.join(", ")}` : `${message}. Allowed: ${allowed?.join(", ")}`;
-    }
-    return errorPath ? `${errorPath}: ${message}` : message;
+    return path3 ? `${path3}: ${issue.message}` : issue.message;
   });
 }
-async function validateFile(filePath, validate, extractor) {
+async function validateFile(filePath, schema, extractor) {
   try {
     if (!await fileExists(filePath)) {
       return { valid: false, errors: [`File not found: ${filePath}`] };
@@ -157,13 +106,13 @@ async function validateFile(filePath, validate, extractor) {
         };
       }
     } else {
-      parsed = parseYaml2(content);
+      parsed = parseYaml(content);
     }
-    const isValid = validate(parsed);
-    if (isValid) {
+    const result = schema.safeParse(parsed);
+    if (result.success) {
       return { valid: true, errors: [] };
     }
-    return { valid: false, errors: formatAjvErrors(validate.errors) };
+    return { valid: false, errors: formatZodErrors(result.error) };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return { valid: false, errors: [`Failed to parse content: ${message}`] };
@@ -183,9 +132,8 @@ async function validateTarget(target, rootDir = process.cwd()) {
   if (files.length === 0) {
     return result;
   }
-  const validate = await getValidator(target.schema, rootDir);
   for (const file of files) {
-    const validation = await validateFile(file, validate, target.extractor);
+    const validation = await validateFile(file, target.schema, target.extractor);
     const relativePath = path.relative(rootDir, file);
     if (validation.valid) {
       result.validFiles++;
@@ -207,9 +155,9 @@ async function validateAllSchemas(rootDir = process.cwd()) {
   }
   const summary = {
     totalSchemas: results.length,
-    totalFiles: results.reduce((sum, r) => sum + r.totalFiles, 0),
-    validFiles: results.reduce((sum, r) => sum + r.validFiles, 0),
-    invalidFiles: results.reduce((sum, r) => sum + r.invalidFiles.length, 0)
+    totalFiles: sumBy(results, (r) => r.totalFiles),
+    validFiles: sumBy(results, (r) => r.validFiles),
+    invalidFiles: sumBy(results, (r) => r.invalidFiles.length)
   };
   return {
     valid: results.every((r) => r.valid),
@@ -251,397 +199,6 @@ function printValidationResults(result) {
   }
 }
 
-// src/cli/lib/plugin-validator.ts
-init_esm_shims();
-import Ajv2 from "ajv";
-import addFormats2 from "ajv-formats";
-import path2 from "path";
-import fg2 from "fast-glob";
-var PLUGIN_DIR = ".claude-plugin";
-var PLUGIN_MANIFEST = "plugin.json";
-var KEBAB_CASE_REGEX = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
-var SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
-var schemaCache2 = /* @__PURE__ */ new Map();
-var validatorCache2 = /* @__PURE__ */ new Map();
-var REMOTE_SCHEMAS = {
-  "skill-frontmatter.schema.json": "https://raw.githubusercontent.com/claude-collective/skills/main/src/schemas/skill-frontmatter.schema.json"
-};
-async function loadSchema2(schemaName) {
-  if (schemaCache2.has(schemaName)) {
-    return schemaCache2.get(schemaName);
-  }
-  const locations = [
-    path2.join(PROJECT_ROOT, "src", "schemas", schemaName),
-    path2.join(process.cwd(), "src", "schemas", schemaName)
-  ];
-  for (const schemaPath of locations) {
-    if (await fileExists(schemaPath)) {
-      const content = await readFile(schemaPath);
-      const schema = JSON.parse(content);
-      schemaCache2.set(schemaName, schema);
-      return schema;
-    }
-  }
-  const remoteUrl = REMOTE_SCHEMAS[schemaName];
-  if (remoteUrl) {
-    try {
-      const response = await fetch(remoteUrl);
-      if (response.ok) {
-        const schema = await response.json();
-        schemaCache2.set(schemaName, schema);
-        return schema;
-      }
-    } catch {
-    }
-  }
-  throw new Error(
-    `Schema not found: ${schemaName}. Searched: ${locations.join(", ")}${remoteUrl ? ` and ${remoteUrl}` : ""}`
-  );
-}
-async function getValidator2(schemaName) {
-  if (validatorCache2.has(schemaName)) {
-    return validatorCache2.get(schemaName);
-  }
-  const ajv = new Ajv2({ allErrors: true, strict: false });
-  addFormats2(ajv);
-  const schema = await loadSchema2(schemaName);
-  const validate = ajv.compile(schema);
-  validatorCache2.set(schemaName, validate);
-  return validate;
-}
-function formatAjvErrors2(errors) {
-  if (!errors) return [];
-  return errors.map((err) => {
-    const errorPath = err.instancePath ? err.instancePath.replace(/^\//, "").replace(/\//g, ".") : "";
-    const message = err.message || "Unknown error";
-    if (err.keyword === "additionalProperties") {
-      const prop = err.params.additionalProperty;
-      return `Unrecognized key: "${prop}"`;
-    }
-    if (err.keyword === "enum") {
-      const allowed = err.params.allowedValues;
-      return errorPath ? `${errorPath}: ${message}. Allowed: ${allowed?.join(", ")}` : `${message}. Allowed: ${allowed?.join(", ")}`;
-    }
-    if (err.keyword === "pattern") {
-      let hint = "";
-      if (errorPath === "name") {
-        hint = " (must be kebab-case)";
-      } else if (errorPath === "version") {
-        hint = " (must be semver: x.y.z)";
-      }
-      return errorPath ? `${errorPath}: ${message}${hint}` : `${message}${hint}`;
-    }
-    return errorPath ? `${errorPath}: ${message}` : message;
-  });
-}
-function isKebabCase(str) {
-  return KEBAB_CASE_REGEX.test(str);
-}
-function isValidSemver(str) {
-  return SEMVER_REGEX.test(str);
-}
-async function validatePluginStructure(pluginPath) {
-  const errors = [];
-  const warnings = [];
-  if (!await directoryExists(pluginPath)) {
-    return {
-      valid: false,
-      errors: [`Plugin directory does not exist: ${pluginPath}`],
-      warnings: []
-    };
-  }
-  const pluginDir = path2.join(pluginPath, PLUGIN_DIR);
-  if (!await directoryExists(pluginDir)) {
-    errors.push(`Missing ${PLUGIN_DIR}/ directory`);
-  }
-  const manifestPath = path2.join(pluginDir, PLUGIN_MANIFEST);
-  if (!await fileExists(manifestPath)) {
-    errors.push(`Missing ${PLUGIN_DIR}/${PLUGIN_MANIFEST}`);
-  }
-  const readmePath = path2.join(pluginPath, "README.md");
-  if (!await fileExists(readmePath)) {
-    warnings.push("Missing README.md (recommended for documentation)");
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-async function validatePluginManifest(manifestPath) {
-  const errors = [];
-  const warnings = [];
-  if (!await fileExists(manifestPath)) {
-    return {
-      valid: false,
-      errors: [`Manifest file not found: ${manifestPath}`],
-      warnings: []
-    };
-  }
-  let manifest;
-  try {
-    const content = await readFile(manifestPath);
-    manifest = JSON.parse(content);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return {
-      valid: false,
-      errors: [`Invalid JSON in ${PLUGIN_MANIFEST}: ${message}`],
-      warnings: []
-    };
-  }
-  const validate = await getValidator2("plugin.schema.json");
-  const isValid = validate(manifest);
-  if (!isValid) {
-    errors.push(...formatAjvErrors2(validate.errors));
-  }
-  if (manifest.name && typeof manifest.name === "string") {
-    if (!isKebabCase(manifest.name)) {
-      errors.push(`name must be kebab-case: "${manifest.name}"`);
-    }
-  }
-  if (manifest.version && typeof manifest.version === "string") {
-    if (!isValidSemver(manifest.version)) {
-      warnings.push(
-        `version "${manifest.version}" is not valid semver (expected: major.minor.patch)`
-      );
-    }
-  }
-  if (!manifest.description) {
-    warnings.push("Missing description field (recommended for discoverability)");
-  }
-  const pluginDir = path2.dirname(path2.dirname(manifestPath));
-  if (manifest.skills && typeof manifest.skills === "string") {
-    const skillsPath = path2.join(pluginDir, manifest.skills);
-    if (!await directoryExists(skillsPath)) {
-      errors.push(`Skills path does not exist: ${manifest.skills}`);
-    }
-  }
-  if (manifest.agents && typeof manifest.agents === "string") {
-    const agentsPath = path2.join(pluginDir, manifest.agents);
-    if (!await directoryExists(agentsPath)) {
-      errors.push(`Agents path does not exist: ${manifest.agents}`);
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-async function validateSkillFrontmatter(skillPath) {
-  const errors = [];
-  const warnings = [];
-  if (!await fileExists(skillPath)) {
-    return {
-      valid: false,
-      errors: [`Skill file not found: ${skillPath}`],
-      warnings: []
-    };
-  }
-  const content = await readFile(skillPath);
-  const frontmatter = extractFrontmatter(content);
-  if (frontmatter === null) {
-    return {
-      valid: false,
-      errors: ["Missing or invalid YAML frontmatter"],
-      warnings: []
-    };
-  }
-  const validate = await getValidator2("skill-frontmatter.schema.json");
-  const isValid = validate(frontmatter);
-  if (!isValid) {
-    errors.push(...formatAjvErrors2(validate.errors));
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-async function validateAgentFrontmatter(agentPath) {
-  const errors = [];
-  const warnings = [];
-  if (!await fileExists(agentPath)) {
-    return {
-      valid: false,
-      errors: [`Agent file not found: ${agentPath}`],
-      warnings: []
-    };
-  }
-  const content = await readFile(agentPath);
-  const frontmatter = extractFrontmatter(content);
-  if (frontmatter === null) {
-    return {
-      valid: false,
-      errors: ["Missing or invalid YAML frontmatter"],
-      warnings: []
-    };
-  }
-  const validate = await getValidator2("agent-frontmatter.schema.json");
-  const isValid = validate(frontmatter);
-  if (!isValid) {
-    errors.push(...formatAjvErrors2(validate.errors));
-  }
-  const fm = frontmatter;
-  if (fm.name && typeof fm.name === "string") {
-    if (!isKebabCase(fm.name)) {
-      errors.push(`name must be kebab-case: "${fm.name}"`);
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-async function validatePlugin(pluginPath) {
-  const errors = [];
-  const warnings = [];
-  const structureResult = await validatePluginStructure(pluginPath);
-  errors.push(...structureResult.errors);
-  warnings.push(...structureResult.warnings);
-  if (!structureResult.valid) {
-    return { valid: false, errors, warnings };
-  }
-  const manifestPath = path2.join(pluginPath, PLUGIN_DIR, PLUGIN_MANIFEST);
-  const manifestResult = await validatePluginManifest(manifestPath);
-  errors.push(...manifestResult.errors);
-  warnings.push(...manifestResult.warnings);
-  let manifest = null;
-  try {
-    const content = await readFile(manifestPath);
-    manifest = JSON.parse(content);
-  } catch {
-  }
-  if (manifest) {
-    if (manifest.skills && typeof manifest.skills === "string") {
-      const skillsDir = path2.join(pluginPath, manifest.skills);
-      if (await directoryExists(skillsDir)) {
-        const skillFiles = await fg2("**/SKILL.md", {
-          cwd: skillsDir,
-          absolute: true
-        });
-        if (skillFiles.length === 0) {
-          warnings.push(
-            `Skills directory exists but contains no SKILL.md files: ${manifest.skills}`
-          );
-        }
-        for (const skillFile of skillFiles) {
-          const relativePath = path2.relative(pluginPath, skillFile);
-          const skillResult = await validateSkillFrontmatter(skillFile);
-          if (!skillResult.valid) {
-            errors.push(...skillResult.errors.map((e) => `${relativePath}: ${e}`));
-          }
-          warnings.push(...skillResult.warnings.map((w) => `${relativePath}: ${w}`));
-        }
-      }
-    }
-    if (manifest.agents && typeof manifest.agents === "string") {
-      const agentsDir = path2.join(pluginPath, manifest.agents);
-      if (await directoryExists(agentsDir)) {
-        const agentFiles = await fg2("*.md", {
-          cwd: agentsDir,
-          absolute: true
-        });
-        if (agentFiles.length === 0) {
-          warnings.push(`Agents directory exists but contains no .md files: ${manifest.agents}`);
-        }
-        for (const agentFile of agentFiles) {
-          const relativePath = path2.relative(pluginPath, agentFile);
-          const agentResult = await validateAgentFrontmatter(agentFile);
-          if (!agentResult.valid) {
-            errors.push(...agentResult.errors.map((e) => `${relativePath}: ${e}`));
-          }
-          warnings.push(...agentResult.warnings.map((w) => `${relativePath}: ${w}`));
-        }
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings
-  };
-}
-async function validateAllPlugins(pluginsDir) {
-  const results = [];
-  if (!await directoryExists(pluginsDir)) {
-    return {
-      valid: false,
-      results: [
-        {
-          name: pluginsDir,
-          result: {
-            valid: false,
-            errors: [`Directory does not exist: ${pluginsDir}`],
-            warnings: []
-          }
-        }
-      ],
-      summary: { total: 0, valid: 0, invalid: 1, withWarnings: 0 }
-    };
-  }
-  const allDirs = await listDirectories(pluginsDir);
-  const pluginDirs = [];
-  for (const dirName of allDirs) {
-    const potentialPluginDir = path2.join(pluginsDir, dirName, PLUGIN_DIR);
-    if (await directoryExists(potentialPluginDir)) {
-      pluginDirs.push(dirName);
-    }
-  }
-  if (pluginDirs.length === 0) {
-    return {
-      valid: false,
-      results: [
-        {
-          name: pluginsDir,
-          result: {
-            valid: false,
-            errors: [
-              `No plugins found in directory: ${pluginsDir}. Plugins must contain a ${PLUGIN_DIR}/ directory.`
-            ],
-            warnings: []
-          }
-        }
-      ],
-      summary: { total: 0, valid: 0, invalid: 1, withWarnings: 0 }
-    };
-  }
-  for (const pluginName of pluginDirs) {
-    const pluginPath = path2.join(pluginsDir, pluginName);
-    const result = await validatePlugin(pluginPath);
-    results.push({ name: pluginName, result });
-  }
-  const summary = {
-    total: results.length,
-    valid: results.filter((r) => r.result.valid).length,
-    invalid: results.filter((r) => !r.result.valid).length,
-    withWarnings: results.filter((r) => r.result.warnings.length > 0).length
-  };
-  return {
-    valid: summary.invalid === 0,
-    results,
-    summary
-  };
-}
-function printPluginValidationResult(name, result, verbose = false) {
-  const status = result.valid ? "\u2713" : "\u2717";
-  if (result.valid && result.warnings.length === 0 && !verbose) {
-    return;
-  }
-  console.log(`
-  ${status} ${name}`);
-  if (result.errors.length > 0) {
-    console.log("    Errors:");
-    result.errors.forEach((e) => console.log(`      - ${e}`));
-  }
-  if (result.warnings.length > 0) {
-    console.log("    Warnings:");
-    result.warnings.forEach((w) => console.log(`      - ${w}`));
-  }
-}
-
 // src/cli/commands/validate.ts
 var Validate = class _Validate extends BaseCommand {
   static summary = "Validate YAML files against schemas or validate compiled plugins";
@@ -696,7 +253,7 @@ var Validate = class _Validate extends BaseCommand {
     }
   }
   async validatePlugins(pluginPath, verbose, all) {
-    const targetPath = pluginPath ? path3.resolve(pluginPath) : process.cwd();
+    const targetPath = pluginPath ? path2.resolve(pluginPath) : process.cwd();
     if (all) {
       await this.validateAllPluginsInDirectory(targetPath, verbose);
     } else {
@@ -742,7 +299,7 @@ var Validate = class _Validate extends BaseCommand {
       const result = await validatePlugin(targetPath);
       const summary = result.valid ? "Done: Plugin is valid" : "Done: Plugin has errors";
       this.log(summary);
-      printPluginValidationResult(path3.basename(targetPath), result, true);
+      printPluginValidationResult(path2.basename(targetPath), result, true);
       if (result.valid && result.warnings.length === 0) {
         this.log("");
         this.logSuccess("Plugin validated successfully");