@skillkit/cli 1.10.0 → 1.11.0

package/dist/index.js

@@ -5790,12 +5790,12 @@ ${learning.title}
     }
     const outputPath = this.output || `.skillkit/exports/${skillName}/SKILL.md`;
     const { dirname: dirname7 } = await import("path");
-    const { existsSync: existsSync21, mkdirSync: mkdirSync10, writeFileSync: writeFileSync11 } = await import("fs");
+    const { existsSync: existsSync23, mkdirSync: mkdirSync11, writeFileSync: writeFileSync12 } = await import("fs");
     const outputDir = dirname7(outputPath);
-    if (!existsSync21(outputDir)) {
-      mkdirSync10(outputDir, { recursive: true });
+    if (!existsSync23(outputDir)) {
+      mkdirSync11(outputDir, { recursive: true });
     }
-    writeFileSync11(outputPath, skillContent, "utf-8");
+    writeFileSync12(outputPath, skillContent, "utf-8");
     console.log(chalk18.green(`\u2713 Exported learning as skill: ${skillName}`));
     console.log(chalk18.gray(`  Path: ${outputPath}`));
     return 0;
@@ -5810,10 +5810,10 @@ ${learning.title}
       console.log(chalk18.gray("Usage: skillkit memory import --input <path>"));
       return 1;
     }
-    const { existsSync: existsSync21, readFileSync: readFileSync11 } = await import("fs");
-    const { resolve: resolve21 } = await import("path");
-    const fullPath = resolve21(inputPath);
-    if (!existsSync21(fullPath)) {
+    const { existsSync: existsSync23, readFileSync: readFileSync12 } = await import("fs");
+    const { resolve: resolve23 } = await import("path");
+    const fullPath = resolve23(inputPath);
+    if (!existsSync23(fullPath)) {
       console.error(chalk18.red(`File not found: ${fullPath}`));
       return 1;
     }
@@ -5823,7 +5823,7 @@ ${learning.title}
       this.global ? void 0 : projectPath
     );
     try {
-      const content = readFileSync11(fullPath, "utf-8");
+      const content = readFileSync12(fullPath, "utf-8");
       const { parse: parseYaml2 } = await import("yaml");
       const data = parseYaml2(content);
       if (!data.learnings || !Array.isArray(data.learnings)) {
@@ -6892,14 +6892,14 @@ var TeamCommand = class extends Command29 {
     }
     const projectPath = process.cwd();
     const bundlePath = join12(projectPath, ".skillkit", "bundles", `${this.name}.json`);
-    const { existsSync: existsSync21, readFileSync: readFileSync11, writeFileSync: writeFileSync11 } = await import("fs");
-    if (!existsSync21(bundlePath)) {
+    const { existsSync: existsSync23, readFileSync: readFileSync12, writeFileSync: writeFileSync12 } = await import("fs");
+    if (!existsSync23(bundlePath)) {
       this.context.stderr.write(chalk21.red(`Bundle "${this.name}" not found. Create it first with bundle-create.
 `));
       return 1;
     }
-    const content = readFileSync11(bundlePath, "utf-8");
-    writeFileSync11(this.output, content, "utf-8");
+    const content = readFileSync12(bundlePath, "utf-8");
+    writeFileSync12(this.output, content, "utf-8");
     this.context.stdout.write(chalk21.green(`\u2713 Bundle exported to: ${this.output}
 `));
     return 0;
@@ -6909,8 +6909,8 @@ var TeamCommand = class extends Command29 {
       this.context.stderr.write(chalk21.red("--source <path> is required for bundle-import\n"));
       return 1;
     }
-    const { existsSync: existsSync21 } = await import("fs");
-    if (!existsSync21(this.source)) {
+    const { existsSync: existsSync23 } = await import("fs");
+    if (!existsSync23(this.source)) {
       this.context.stderr.write(chalk21.red(`Bundle file not found: ${this.source}
 `));
       return 1;
@@ -7078,8 +7078,8 @@ var PluginCommand = class extends Command30 {
     }
     const projectPath = this.global ? join13(homedir2(), ".skillkit") : process.cwd();
     const pluginsDir = this.global ? join13(projectPath, "plugins") : join13(projectPath, ".skillkit", "plugins");
-    const isLocalPath4 = this.source.startsWith("./") || this.source.startsWith("../") || this.source.startsWith("/") || this.source.startsWith("~") || this.source.includes("\\") || isAbsolute(this.source);
-    if (isLocalPath4 && existsSync15(resolvedSource)) {
+    const isLocalPath5 = this.source.startsWith("./") || this.source.startsWith("../") || this.source.startsWith("/") || this.source.startsWith("~") || this.source.includes("\\") || isAbsolute(this.source);
+    if (isLocalPath5 && existsSync15(resolvedSource)) {
       const targetDir = join13(pluginsDir, pluginName);
       const resolvedTarget = resolve13(targetDir);
       const resolvedPluginsDir = resolve13(pluginsDir);
@@ -10815,6 +10815,7 @@ var CheckCommand = class extends Command39 {
 // src/commands/find.ts
 init_onboarding();
 import { Command as Command40, Option as Option39 } from "clipanion";
+import { FederatedSearch, GitHubSkillRegistry, RateLimitError } from "@skillkit/core";
 
 // ../../marketplace/skills.json
 var skills_default = {
@@ -136493,6 +136494,9 @@ var FindCommand = class extends Command40 {
   quiet = Option39.Boolean("--quiet,-q", false, {
     description: "Minimal output (just list skills)"
   });
+  federated = Option39.Boolean("--federated,-f", false, {
+    description: "Search external registries (GitHub SKILL.md files)"
+  });
   async execute() {
     const s = spinner2();
     const limit = parseInt(this.limit, 10) || 10;
@@ -136542,12 +136546,42 @@ var FindCommand = class extends Command40 {
         results = allSkills.slice(0, limit);
       }
     }
+    if (this.federated && this.query) {
+      s.start("Searching external registries...");
+      const fedSearch = new FederatedSearch();
+      fedSearch.addRegistry(new GitHubSkillRegistry());
+      try {
+        const fedResult = await fedSearch.search(this.query, { limit: parseInt(this.limit, 10) || 10 });
+        s.stop(`Found ${fedResult.total} external skill(s) from ${fedResult.registries.join(", ") || "none"}`);
+        if (fedResult.skills.length > 0) {
+          console.log("");
+          console.log(colors.bold("External Skills (SKILL.md):"));
+          for (const skill of fedResult.skills) {
+            const stars = typeof skill.stars === "number" ? colors.muted(` \u2605${skill.stars}`) : "";
+            const desc = skill.description ? colors.muted(` - ${skill.description.slice(0, 50)}${skill.description.length > 50 ? "..." : ""}`) : "";
+            console.log(`  ${colors.cyan(symbols.bullet)} ${colors.primary(skill.name)}${stars}${desc}`);
+            if (!this.quiet) {
+              console.log(`    ${colors.muted(skill.source)}`);
+            }
+          }
+          console.log("");
+        }
+      } catch (err) {
+        if (err instanceof RateLimitError) {
+          s.stop(colors.warning("Rate limited by GitHub API"));
+          console.log(colors.muted("Set GITHUB_TOKEN env var or wait before retrying."));
+        } else {
+          s.stop(colors.warning("Federated search failed"));
+        }
+      }
+    }
     if (results.length === 0) {
       console.log(colors.muted("No skills found matching your search"));
       console.log("");
       console.log(colors.muted("Try:"));
-      console.log(colors.muted("  skillkit find --top     # Show featured skills"));
-      console.log(colors.muted("  skillkit ui             # Browse in TUI"));
+      console.log(colors.muted("  skillkit find --top       # Show featured skills"));
+      console.log(colors.muted("  skillkit find -f <query>  # Search external registries"));
+      console.log(colors.muted("  skillkit ui               # Browse in TUI"));
       return 0;
     }
     console.log("");
@@ -139409,6 +139443,631 @@ var TreeCommand = class extends Command49 {
   }
 };
 
+// src/commands/quick.ts
+init_helpers();
+init_onboarding();
+import { existsSync as existsSync21, mkdirSync as mkdirSync10, cpSync as cpSync4, rmSync as rmSync5, symlinkSync as symlinkSync2 } from "fs";
+import { join as join20, resolve as resolve21, normalize } from "path";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { Command as Command50 } from "clipanion";
+import {
+  ContextManager as ContextManager3,
+  RecommendationEngine as RecommendationEngine2,
+  loadIndex as loadIndexFromCache4,
+  isIndexStale as isIndexStale2,
+  buildSkillIndex as buildSkillIndex2,
+  saveIndex as saveIndex2,
+  KNOWN_SKILL_REPOS as KNOWN_SKILL_REPOS2,
+  isPathInside as isPathInside2,
+  isLocalPath as isLocalPath4,
+  detectProvider as detectProvider4
+} from "@skillkit/core";
+import { getAdapter as getAdapter6, detectAgent as detectAgent5, getAllAdapters as getAllAdapters6 } from "@skillkit/agents";
+var execFileAsync2 = promisify2(execFile2);
+function truncate6(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+var QuickCommand = class extends Command50 {
+  static paths = [["quick"]];
+  static usage = Command50.Usage({
+    description: "Zero-friction skill setup: detect agents, analyze project, recommend and install",
+    examples: [
+      ["Quick setup", "$0 quick"]
+    ]
+  });
+  async execute() {
+    const s = spinner2();
+    try {
+      welcome();
+      step(`${colors.bold("Quick Setup")} - zero-friction skill installation`);
+      console.log("");
+      s.start("Detecting installed AI agents...");
+      const allAdapters = getAllAdapters6();
+      const detectedAgents = [];
+      for (const adapter of allAdapters) {
+        try {
+          const installDir = getInstallDir(false, adapter.type);
+          const globalDir = getInstallDir(true, adapter.type);
+          if (existsSync21(installDir) || existsSync21(globalDir) || existsSync21(adapter.configFile)) {
+            detectedAgents.push(adapter.type);
+          }
+        } catch {
+        }
+      }
+      if (detectedAgents.length === 0) {
+        const fallback = await detectAgent5();
+        detectedAgents.push(fallback);
+      }
+      s.stop(`Detected ${detectedAgents.length} agent${detectedAgents.length !== 1 ? "s" : ""}: ${detectedAgents.map(formatAgent).join(", ")}`);
+      s.start("Analyzing project...");
+      const targetPath = resolve21(process.cwd());
+      const manager = new ContextManager3(targetPath);
+      let context = manager.get();
+      if (!context) {
+        context = manager.init();
+      }
+      s.stop("Project analyzed");
+      if (!context) {
+        error("Failed to analyze project");
+        return 1;
+      }
+      const profile = {
+        name: context.project.name,
+        type: context.project.type,
+        stack: context.stack,
+        patterns: context.patterns,
+        installedSkills: context.skills?.installed || [],
+        excludedSkills: context.skills?.excluded || []
+      };
+      const languages = profile.stack.languages.map((l) => `${l.name}${l.version ? ` ${l.version}` : ""}`);
+      const frameworks = profile.stack.frameworks.map((f) => `${f.name}${f.version ? ` ${f.version}` : ""}`);
+      showProjectSummary({
+        name: profile.name,
+        type: profile.type,
+        languages,
+        frameworks
+      });
+      let index = loadIndexFromCache4();
+      if (!index || index.skills.length === 0) {
+        s.start("Building skill index from known sources...");
+        try {
+          const result2 = await buildSkillIndex2(KNOWN_SKILL_REPOS2, (message) => {
+            s.message(message);
+          });
+          index = result2.index;
+          saveIndex2(index);
+          s.stop(`Indexed ${index.skills.length} skills`);
+        } catch {
+          s.stop(colors.error("Failed to build index"));
+          warn("Could not fetch skill index. Try running: skillkit recommend --update");
+          return 1;
+        }
+      } else if (isIndexStale2(index)) {
+        step(colors.muted('Skill index is stale. Run "skillkit recommend --update" to refresh.'));
+      }
+      const engine = new RecommendationEngine2();
+      engine.loadIndex(index);
+      const result = engine.recommend(profile, {
+        limit: 5,
+        minScore: 20,
+        excludeInstalled: true,
+        includeReasons: true
+      });
+      const recommendations = result.recommendations;
+      if (recommendations.length === 0) {
+        warn("No matching skills found for your project.");
+        console.log(colors.muted("Try running: skillkit recommend --update"));
+        return 0;
+      }
+      console.log("");
+      console.log(colors.bold(`Top ${recommendations.length} Recommended Skills:`));
+      console.log("");
+      const options = [];
+      for (let i = 0; i < recommendations.length; i++) {
+        const rec = recommendations[i];
+        let scoreColor;
+        if (rec.score >= 70) {
+          scoreColor = colors.success;
+        } else if (rec.score >= 50) {
+          scoreColor = colors.warning;
+        } else {
+          scoreColor = colors.muted;
+        }
+        const scoreBar = progressBar(rec.score, 100, 10);
+        const qualityScore = rec.skill.quality ?? null;
+        const qualityDisplay = typeof qualityScore === "number" && Number.isFinite(qualityScore) ? ` ${formatQualityBadge(qualityScore)}` : "";
+        console.log(`  ${colors.bold(`${i + 1}.`)} ${scoreColor(`${rec.score}%`)} ${colors.dim(scoreBar)} ${colors.bold(rec.skill.name)}${qualityDisplay}`);
+        if (rec.skill.description) {
+          console.log(`     ${colors.muted(truncate6(rec.skill.description, 70))}`);
+        }
+        options.push({
+          value: `${i}`,
+          label: `${rec.skill.name} (${rec.score}% match)`,
+          hint: rec.skill.source || void 0
+        });
+      }
+      console.log("");
+      const skipOption = { value: "skip", label: "Skip installation" };
+      const selectResult = await select2({
+        message: "Select a skill to install",
+        options: [...options, skipOption]
+      });
+      if (isCancel2(selectResult) || selectResult === "skip") {
+        cancel2("Quick setup complete (no installation)");
+        return 0;
+      }
+      const selectedIndex = parseInt(selectResult, 10);
+      const selectedSkill = recommendations[selectedIndex];
+      if (!selectedSkill || !selectedSkill.skill.source) {
+        error("Selected skill has no installable source");
+        return 1;
+      }
+      const agentDisplay = detectedAgents.length <= 3 ? detectedAgents.map(formatAgent).join(", ") : `${detectedAgents.slice(0, 2).map(formatAgent).join(", ")} +${detectedAgents.length - 2} more`;
+      const confirmResult = await confirm2({
+        message: `Install ${colors.bold(selectedSkill.skill.name)} to ${agentDisplay}?`,
+        initialValue: true
+      });
+      if (isCancel2(confirmResult) || !confirmResult) {
+        cancel2("Installation cancelled");
+        return 0;
+      }
+      saveLastAgents(detectedAgents);
+      const providerAdapter = detectProvider4(selectedSkill.skill.source);
+      if (!providerAdapter) {
+        error(`Could not detect provider for: ${selectedSkill.skill.source}`);
+        return 1;
+      }
+      s.start(`Fetching ${selectedSkill.skill.name}...`);
+      const cloneResult = await providerAdapter.clone(selectedSkill.skill.source, "", { depth: 1 });
+      if (!cloneResult.success || !cloneResult.path) {
+        s.stop(colors.error(cloneResult.error || "Failed to fetch source"));
+        return 1;
+      }
+      const discoveredSkills = cloneResult.discoveredSkills || [];
+      const matchedSkill = discoveredSkills.find((ds) => ds.name === selectedSkill.skill.name) || discoveredSkills[0];
+      if (!matchedSkill) {
+        s.stop(colors.error("Skill not found in repository"));
+        return 1;
+      }
+      s.stop(`Found ${selectedSkill.skill.name}`);
+      let primaryPath = null;
+      const installedAgents = [];
+      for (const agentType of detectedAgents) {
+        const adapter = getAdapter6(agentType);
+        const installDir = getInstallDir(false, agentType);
+        if (!existsSync21(installDir)) {
+          mkdirSync10(installDir, { recursive: true });
+        }
+        const sanitizedName = matchedSkill.name.split(/[/\\]/).pop() || matchedSkill.name;
+        const targetInstallPath = normalize(join20(installDir, sanitizedName));
+        if (!isPathInside2(targetInstallPath, installDir)) {
+          error(`Skipping ${matchedSkill.name} for ${adapter.name} (install path escapes target directory)`);
+          continue;
+        }
+        const securityRoot = cloneResult.tempRoot || cloneResult.path;
+        if (!isPathInside2(matchedSkill.path, securityRoot)) {
+          error(`Skipping ${matchedSkill.name} for ${adapter.name} (path traversal detected)`);
+          continue;
+        }
+        const useSymlink = detectedAgents.length > 1 && primaryPath !== null;
+        s.start(`Installing to ${adapter.name}${useSymlink ? " (symlink)" : ""}...`);
+        try {
+          if (existsSync21(targetInstallPath)) {
+            rmSync5(targetInstallPath, { recursive: true, force: true });
+          }
+          if (useSymlink && primaryPath) {
+            symlinkSync2(primaryPath, targetInstallPath, "dir");
+          } else {
+            cpSync4(matchedSkill.path, targetInstallPath, { recursive: true, dereference: true });
+            if (detectedAgents.length > 1 && primaryPath === null) {
+              primaryPath = targetInstallPath;
+            }
+            const packageJsonPath = join20(targetInstallPath, "package.json");
+            if (existsSync21(packageJsonPath)) {
+              s.stop(`Installed to ${adapter.name}`);
+              s.start("Installing npm dependencies...");
+              try {
+                await execFileAsync2("npm", ["install", "--production"], { cwd: targetInstallPath });
+                s.stop("Dependencies installed");
+              } catch {
+                s.stop(colors.warning("Dependencies failed"));
+                console.log(colors.muted("Run manually: npm install in " + targetInstallPath));
+              }
+              s.start("Finishing installation...");
+            }
+          }
+          const metadata = {
+            name: matchedSkill.name,
+            description: selectedSkill.skill.description || "",
+            source: selectedSkill.skill.source,
+            sourceType: providerAdapter.type,
+            subpath: matchedSkill.name,
+            installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            enabled: true
+          };
+          saveSkillMetadata(targetInstallPath, metadata);
+          installedAgents.push(agentType);
+          s.stop(`Installed to ${adapter.name}${useSymlink ? " (symlink)" : ""}`);
+        } catch (err) {
+          s.stop(colors.error(`Failed to install to ${adapter.name}`));
+          console.log(colors.muted(err instanceof Error ? err.message : String(err)));
+        }
+      }
+      const cleanupPath = cloneResult.tempRoot || cloneResult.path;
+      if (!isLocalPath4(selectedSkill.skill.source) && cleanupPath && existsSync21(cleanupPath)) {
+        rmSync5(cleanupPath, { recursive: true, force: true });
+      }
+      if (installedAgents.length > 0) {
+        console.log("");
+        success(`Installed ${colors.bold(matchedSkill.name)} to ${installedAgents.length} agent${installedAgents.length !== 1 ? "s" : ""}`);
+        for (const a of installedAgents) {
+          console.log(colors.muted(`  ${symbols.success} ${getAgentIcon(a)} ${formatAgent(a)}`));
+        }
+        console.log("");
+        const badgeUrl = `https://img.shields.io/badge/SkillKit-${encodeURIComponent(matchedSkill.name)}-black?style=flat-square`;
+        console.log(colors.dim("Add to your README:"));
+        console.log(colors.muted(`  [![SkillKit](${badgeUrl})](https://agenstskills.com)`));
+        outro2("Quick setup complete!");
+        console.log("");
+        console.log(colors.muted("Next steps:"));
+        console.log(colors.muted(`  ${symbols.arrowRight} Run ${colors.cyan("skillkit sync")} to update agent configs`));
+        console.log(colors.muted(`  ${symbols.arrowRight} Run ${colors.cyan("skillkit recommend")} for more suggestions`));
+        console.log(colors.muted(`  ${symbols.arrowRight} Run ${colors.cyan("skillkit list")} to see installed skills`));
+        console.log("");
+      } else {
+        warn("No agents were installed");
+      }
+      return 0;
+    } catch (err) {
+      s.stop(colors.error("Quick setup failed"));
+      console.log(colors.muted(err instanceof Error ? err.message : String(err)));
+      return 1;
+    }
+  }
+};
+
+// src/commands/skillmd.ts
+init_onboarding();
+import { existsSync as existsSync22, readFileSync as readFileSync11, writeFileSync as writeFileSync11, readdirSync as readdirSync4 } from "fs";
+import { join as join21, resolve as resolve22, basename as basename6, relative } from "path";
+import { Command as Command51, Option as Option49 } from "clipanion";
+function validateSkillMd(filePath) {
+  const result = {
+    path: filePath,
+    exists: false,
+    hasName: false,
+    hasDescription: false,
+    hasTriggers: false,
+    hasCapabilities: false,
+    triggerCount: 0,
+    capabilityCount: 0,
+    score: 0,
+    issues: []
+  };
+  if (!existsSync22(filePath)) {
+    result.issues.push("File does not exist");
+    return result;
+  }
+  result.exists = true;
+  const content = readFileSync11(filePath, "utf-8");
+  if (!content.trim()) {
+    result.issues.push("File is empty");
+    return result;
+  }
+  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  const bodyContent = frontmatterMatch ? content.slice(frontmatterMatch[0].length) : content;
+  if (frontmatterMatch) {
+    const frontmatter = frontmatterMatch[1];
+    if (/^name:\s*.+$/m.test(frontmatter)) result.hasName = true;
+    if (/^description:\s*.+$/m.test(frontmatter)) result.hasDescription = true;
+  }
+  if (!result.hasName) {
+    if (/^#\s+.+$/m.test(bodyContent)) result.hasName = true;
+  }
+  if (!result.hasDescription) {
+    if (/^##?\s*(description|about|overview)\b/im.test(bodyContent)) {
+      result.hasDescription = true;
+    } else {
+      const lines = bodyContent.split(/\r?\n/).filter((l) => l.trim());
+      const nonHeaderLines = lines.filter((l) => !l.startsWith("#"));
+      if (nonHeaderLines.length >= 2) result.hasDescription = true;
+    }
+  }
+  const triggerPatterns = [
+    /triggers?\s*when/i,
+    /when\s*to\s*use/i,
+    /use\s*this\s*when/i,
+    /\*\*triggers?\b/i,
+    /^[-*]\s+.+(when|if|pattern|trigger)/im,
+    /glob:/i
+  ];
+  for (const pattern of triggerPatterns) {
+    if (pattern.test(content)) {
+      result.hasTriggers = true;
+      break;
+    }
+  }
+  if (result.hasTriggers) {
+    const triggerSection = content.match(/triggers?\s*when[:\s]*\n((?:[-*]\s+.+\n?)+)/i);
+    result.triggerCount = triggerSection ? (triggerSection[1].match(/^[-*]\s+/gm) || []).length : 1;
+  }
+  const capabilityPatterns = [
+    /capabilities?[:\s]/i,
+    /features?[:\s]/i,
+    /what\s*(it|this)\s*(does|can)/i,
+    /^##?\s*capabilities/im,
+    /^##?\s*features/im
+  ];
+  for (const pattern of capabilityPatterns) {
+    if (pattern.test(content)) {
+      result.hasCapabilities = true;
+      break;
+    }
+  }
+  if (result.hasCapabilities) {
+    const capSection = content.match(/(?:capabilities?|features?)[:\s]*\n((?:[-*]\s+.+\n?)+)/i);
+    result.capabilityCount = capSection ? (capSection[1].match(/^[-*]\s+/gm) || []).length : 1;
+  }
+  if (!result.hasName) result.issues.push("Missing name field");
+  if (!result.hasDescription) result.issues.push("Missing description section");
+  if (!result.hasTriggers) result.issues.push("No trigger patterns found");
+  if (!result.hasCapabilities) result.issues.push("No capabilities list found");
+  let score = 0;
+  if (result.exists) score += 10;
+  if (result.hasName) score += 20;
+  if (result.hasDescription) score += 25;
+  if (result.hasTriggers) score += 20;
+  if (result.hasCapabilities) score += 15;
+  if (result.triggerCount >= 3) score += 5;
+  if (result.capabilityCount >= 3) score += 5;
+  if (frontmatterMatch) {
+    const fm = frontmatterMatch[1];
+    if (/^version:/m.test(fm)) score += 3;
+    if (/^license:/m.test(fm)) score += 2;
+    if (/^tags:/m.test(fm)) score += 3;
+    if (/^metadata:/m.test(fm)) score += 2;
+  }
+  result.score = Math.min(100, score);
+  return result;
+}
+function printValidation(validation, verbose = false) {
+  const scoreColor = validation.score >= 80 ? colors.success : validation.score >= 60 ? colors.warning : colors.error;
+  console.log(`  ${colors.muted("Score:")} ${scoreColor(`${validation.score}`)}/100`);
+  console.log(`  ${validation.hasName ? colors.success(symbols.success) : colors.error(symbols.error)} Name field`);
+  console.log(`  ${validation.hasDescription ? colors.success(symbols.success) : colors.error(symbols.error)} Description section`);
+  console.log(`  ${validation.hasTriggers ? colors.success(symbols.success) : colors.error(symbols.error)} Trigger patterns${validation.triggerCount > 0 ? ` (${validation.triggerCount})` : ""}`);
+  console.log(`  ${validation.hasCapabilities ? colors.success(symbols.success) : colors.error(symbols.error)} Capabilities list${validation.capabilityCount > 0 ? ` (${validation.capabilityCount})` : ""}`);
+  if (verbose && validation.issues.length > 0) {
+    console.log("");
+    console.log(`  ${colors.warning("Issues:")}`);
+    for (const issue of validation.issues) {
+      console.log(`    ${colors.warning(symbols.warning)} ${issue}`);
+    }
+  }
+}
+var SkillMdValidateCommand = class extends Command51 {
+  static paths = [["skillmd", "validate"], ["skill-md", "validate"]];
+  static usage = Command51.Usage({
+    description: "Validate a SKILL.md file against the standard",
+    examples: [
+      ["Validate SKILL.md in current directory", "$0 skillmd validate"],
+      ["Validate specific file", "$0 skillmd validate ./path/to/SKILL.md"]
+    ]
+  });
+  targetPath = Option49.String({ required: false, name: "path" });
+  verbose = Option49.Boolean("--verbose,-v", false, {
+    description: "Show detailed validation results"
+  });
+  json = Option49.Boolean("--json", false, {
+    description: "Output as JSON"
+  });
+  async execute() {
+    const targetPath = this.targetPath || join21(process.cwd(), "SKILL.md");
+    const resolvedPath = resolve22(targetPath);
+    const filePath = resolvedPath.endsWith("SKILL.md") ? resolvedPath : join21(resolvedPath, "SKILL.md");
+    if (!this.json) {
+      header("SKILL.md Validation");
+      step(`Validating: ${colors.cyan(filePath)}`);
+      console.log("");
+    }
+    const validation = validateSkillMd(filePath);
+    if (this.json) {
+      console.log(JSON.stringify(validation, null, 2));
+      return validation.score >= 60 ? 0 : 1;
+    }
+    console.log(colors.primary(basename6(filePath)));
+    printValidation(validation, this.verbose);
+    console.log("");
+    if (validation.score >= 80) {
+      success(`SKILL.md is compliant (score: ${validation.score}/100)`);
+    } else if (validation.score >= 60) {
+      warn(`SKILL.md needs improvement (score: ${validation.score}/100)`);
+    } else {
+      error(`SKILL.md does not meet minimum standard (score: ${validation.score}/100)`);
+    }
+    return validation.score >= 60 ? 0 : 1;
+  }
+};
+var SkillMdInitCommand = class extends Command51 {
+  static paths = [["skillmd", "init"], ["skill-md", "init"]];
+  static usage = Command51.Usage({
+    description: "Create a template SKILL.md in the current directory",
+    examples: [
+      ["Create SKILL.md template", "$0 skillmd init"],
+      ["Create with custom name", "$0 skillmd init --name my-skill"]
+    ]
+  });
+  name = Option49.String("--name,-n", {
+    description: "Skill name"
+  });
+  force = Option49.Boolean("--force,-f", false, {
+    description: "Overwrite existing SKILL.md"
+  });
+  async execute() {
+    const outputPath = join21(process.cwd(), "SKILL.md");
+    if (existsSync22(outputPath) && !this.force) {
+      warn("SKILL.md already exists");
+      console.log(colors.muted("Use --force to overwrite"));
+      return 1;
+    }
+    const skillName = this.name || basename6(process.cwd());
+    const formattedName = skillName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+    const template = [
+      "---",
+      `name: ${skillName}`,
+      "description: What this skill does and when to use it",
+      'version: "1.0"',
+      "license: MIT",
+      "tags: [general]",
+      "metadata:",
+      "  author: your-name",
+      "---",
+      "",
+      `# ${formattedName}`,
+      "",
+      "Brief description of what this skill provides to AI coding agents.",
+      "",
+      "## Triggers when:",
+      `- User asks about ${skillName} related tasks`,
+      `- Project contains ${skillName} configuration files`,
+      `- Code changes involve ${skillName} patterns`,
+      "",
+      "## Capabilities:",
+      `- Provides best practices for ${skillName}`,
+      "- Generates boilerplate code and configurations",
+      "- Validates existing implementations",
+      "- Suggests improvements and optimizations",
+      "",
+      "## Steps",
+      "1. First step the AI agent should take",
+      "2. Second step with specific instructions",
+      "3. Third step with expected outcome",
+      "",
+      "## Examples",
+      "",
+      "```",
+      "Example code or configuration here",
+      "```",
+      ""
+    ].join("\n");
+    writeFileSync11(outputPath, template);
+    success(`Created SKILL.md for "${skillName}"`);
+    console.log("");
+    console.log(colors.muted("Next steps:"));
+    console.log(`  ${colors.cyan("1.")} Edit SKILL.md with your skill instructions`);
+    console.log(`  ${colors.cyan("2.")} Run ${colors.cyan("skillkit skillmd validate")} to check compliance`);
+    console.log(`  ${colors.cyan("3.")} Run ${colors.cyan("skillkit publish submit")} to share with the marketplace`);
+    return 0;
+  }
+};
+var SkillMdCheckCommand = class extends Command51 {
+  static paths = [["skillmd", "check"], ["skill-md", "check"]];
+  static usage = Command51.Usage({
+    description: "Check all SKILL.md files in the project for compliance",
+    examples: [
+      ["Check current directory", "$0 skillmd check"],
+      ["Check specific directory", "$0 skillmd check ./skills"]
+    ]
+  });
+  targetPath = Option49.String({ required: false, name: "path" });
+  verbose = Option49.Boolean("--verbose,-v", false, {
+    description: "Show detailed validation results"
+  });
+  async execute() {
+    const targetPath = resolve22(this.targetPath || process.cwd());
+    header("SKILL.md Compliance Check");
+    const s = spinner2();
+    s.start("Scanning for SKILL.md files...");
+    const skillMdFiles = this.findSkillMdFiles(targetPath);
+    s.stop(`Found ${skillMdFiles.length} SKILL.md file(s)`);
+    if (skillMdFiles.length === 0) {
+      warn("No SKILL.md files found");
+      console.log(colors.muted(`Searched: ${targetPath}`));
+      console.log("");
+      console.log(colors.muted("Create one with:"));
+      console.log(`  ${colors.cyan("skillkit skillmd init")}`);
+      return 0;
+    }
+    const validations = skillMdFiles.map((f) => validateSkillMd(f));
+    validations.sort((a, b) => b.score - a.score);
+    console.log("");
+    for (const validation of validations) {
+      const relativePath = relative(targetPath, validation.path);
+      const scoreColor = validation.score >= 80 ? colors.success : validation.score >= 60 ? colors.warning : colors.error;
+      console.log(`${scoreColor(symbols.bullet)} ${colors.primary(relativePath)} ${colors.muted(`(${validation.score}/100)`)}`);
+      if (this.verbose) {
+        printValidation(validation, true);
+        console.log("");
+      }
+    }
+    console.log("");
+    const passing = validations.filter((v) => v.score >= 60).length;
+    const failing = validations.filter((v) => v.score < 60).length;
+    const avgScore = Math.round(validations.reduce((sum, v) => sum + v.score, 0) / validations.length);
+    console.log(colors.muted("Summary:"));
+    console.log(`  ${colors.muted("Total:")} ${validations.length}`);
+    console.log(`  ${colors.success(symbols.success)} Passing (60+): ${passing}`);
+    if (failing > 0) {
+      console.log(`  ${colors.error(symbols.error)} Failing: ${failing}`);
+    }
+    console.log(`  ${colors.muted("Average score:")} ${avgScore}/100`);
+    console.log("");
+    if (failing > 0) {
+      error(`${failing} SKILL.md file(s) below minimum standard`);
+      return 1;
+    }
+    success("All SKILL.md files are compliant");
+    return 0;
+  }
+  findSkillMdFiles(dir) {
+    const results = [];
+    const directFile = join21(dir, "SKILL.md");
+    if (existsSync22(directFile)) results.push(directFile);
+    const searchDirs = [
+      join21(dir, "skills"),
+      join21(dir, ".claude", "skills"),
+      join21(dir, ".cursor", "skills"),
+      join21(dir, ".codex", "skills"),
+      join21(dir, ".github", "skills")
+    ];
+    for (const searchDir of searchDirs) {
+      if (!existsSync22(searchDir)) continue;
+      this.scanDir(searchDir, results, 0);
+    }
+    try {
+      const entries = readdirSync4(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        const entrySkillMd = join21(dir, entry.name, "SKILL.md");
+        if (existsSync22(entrySkillMd) && !results.includes(entrySkillMd)) {
+          results.push(entrySkillMd);
+        }
+      }
+    } catch {
+    }
+    return results;
+  }
+  scanDir(dir, results, depth) {
+    if (depth > 3) return;
+    try {
+      const entries = readdirSync4(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = join21(dir, entry.name);
+        if (entry.isFile() && entry.name === "SKILL.md") {
+          if (!results.includes(entryPath)) results.push(entryPath);
+        }
+        if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+          this.scanDir(entryPath, results, depth + 1);
+        }
+      }
+    } catch {
+    }
+  }
+};
+
 // src/index.ts
 init_helpers();
 export {
@@ -139478,6 +140137,7 @@ export {
   ProfileRemoveCommand,
   PublishCommand,
   PublishSubmitCommand,
+  QuickCommand,
   ReadCommand,
   RecommendCommand,
   RemoveCommand,
@@ -139492,6 +140152,9 @@ export {
   SessionStartCommand,
   SessionStatusCommand,
   SettingsCommand,
+  SkillMdCheckCommand,
+  SkillMdInitCommand,
+  SkillMdValidateCommand,
   StatusCommand,
   SyncCommand,
   TeamCommand,