myskill 1.0.0 → 1.2.0

package/README.md

@@ -125,6 +125,8 @@ myskill doctor
 | ----------- | ---------------------------------------------------------------------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `create`    | Create a new skill interactively or via flags.                         | `myskill create [options]`              | `-n, --name <name>`: Skill name (lowercase alphanumeric with hyphens)<br>`-p, --platform <platform>`: Target platform (claude, opencode, codex, gemini)<br>`-d, --description <description>`: Skill description<br>`-s, --scope <scope>`: Scope (global, project). Default: project<br>`--non-interactive`: Run without interactive prompts |
 | `list`      | List all installed skills for a platform.                              | `myskill list [options]`                | `-p, --platform <platform>`: Filter by platform                                                                                                                                                                                                                                                                                             |
+| `platforms` | List all supported platforms.                                          | `myskill platforms`                     | None                                                                                                                                                                                                                                                                                                                                        |
+| `detect`    | Detect skills in directory and identify their platforms.               | `myskill detect [path]`                 | `[path]`: Path to directory to scan (default: current directory)                                                                                                                                                                                                                                                                            |
 | `find`      | Find skills by name or description with fuzzy search.                  | `myskill find [query] [options]`        | `[query]`: Search query (supports fuzzy matching)<br>`-p, --platform <platform>`: Filter by platform                                                                                                                                                                                                                                        |
 | `validate`  | Validate a skill's structure and frontmatter against platform schemas. | `myskill validate [path] [options]`     | `[path]`: Path to skill directory. Default: current directory<br>`-p, --platform <platform>`: Validate against specific platform                                                                                                                                                                                                            |
 | `run`       | Run a skill script (experimental).                                     | `myskill run <skill> [args...]`         | `<skill>`: Skill name or path<br>`[args...]`: Arguments to pass to the skill script                                                                                                                                                                                                                                                         |

package/bin/myskill.js

@@ -51,8 +51,9 @@ program
 program
   .command("install")
   .description("Install a skill")
-  .argument("<path>", "Path to skill directory")
+  .argument("[path]", "Path to skill directory")
   .option("-p, --platform <platform>", "Target platform")
+
   .option("-f, --force", "Force overwrite if installed")
   .option("--non-interactive", "Run without interactive prompts")
   .action(async (pathStr, options) => {
@@ -134,4 +135,21 @@ program
     run(skillName, args);
   });
 
+program
+  .command("platforms")
+  .description("List all supported platforms")
+  .action(async () => {
+    const { platformsCommand } = await import("../src/commands/platforms.js");
+    platformsCommand();
+  });
+
+program
+  .command("detect")
+  .description("Detect skills in directory")
+  .argument("[path]", "Path to directory to scan", ".")
+  .action(async (pathStr) => {
+    const { detect } = await import("../src/commands/detect.js");
+    detect(pathStr);
+  });
+
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myskill",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "CLI tool for creating and managing AI agent skills",
   "author": "Sarfraz Ahmed <sarfraznawaz2005@gmail.com>",
   "license": "MIT",

package/src/commands/detect.js

@@ -0,0 +1,32 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import { findSkills } from "../utils/skills.js";
+
+export async function detect(pathStr = ".", options = {}) {
+  const targetDir = pathStr === "." ? process.cwd() : path.resolve(pathStr);
+
+  console.log(chalk.blue(`Detecting skills in: ${targetDir}\n`));
+
+  try {
+    const skills = await findSkills(targetDir);
+
+    if (skills.length === 0) {
+      console.log(chalk.yellow("No skills detected in current directory."));
+      return;
+    }
+
+    for (const skill of skills) {
+      if (skill.error) {
+        console.log(`${chalk.bold(skill.name)}: ${chalk.red(skill.error)}`);
+        continue;
+      }
+      console.log(
+        `${chalk.bold(skill.name)}: ${chalk.green(skill.platform.name)} (${skill.platform.id})`,
+      );
+      console.log(`  Description: ${skill.description}`);
+    }
+  } catch (e) {
+    console.error(chalk.red(`Error scanning directory: ${e.message}`));
+  }
+}

package/src/commands/install.js

@@ -3,48 +3,10 @@ import path from "path";
 import chalk from "chalk";
 import { platforms, getPlatformPath } from "../platforms/index.js";
 import { promptWithCancellation } from "../utils/prompt.js";
+import { findSkills } from "../utils/skills.js";
 
-export async function install(sourcePath, options = {}) {
-  const resolvedSource = path.resolve(sourcePath);
-  if (!(await fs.pathExists(resolvedSource))) {
-    console.error(
-      chalk.red(`Error: Source path ${resolvedSource} does not exist`),
-    );
-    process.exit(1);
-  }
-
-  let platform;
-  if (options.platform) {
-    platform = platforms[options.platform];
-    if (!platform) {
-      console.error(chalk.red(`Error: Unknown platform '${options.platform}'`));
-      process.exit(1);
-    }
-  } else {
-    console.log(
-      chalk.yellow("Platform not specified. Attempting to detect..."),
-    );
-
-    const skillMdPath = path.join(resolvedSource, "SKILL.md");
-    if (await fs.pathExists(skillMdPath)) {
-      // Exists
-    }
-
-    const answers = await promptWithCancellation([
-      {
-        type: "list",
-        name: "platform",
-        message: "Select target platform to install to:",
-        choices: Object.values(platforms).map((p) => ({
-          name: p.name,
-          value: p.id,
-        })),
-      },
-    ]);
-    platform = platforms[answers.platform];
-  }
-
-  const skillName = path.basename(resolvedSource);
+async function installToPlatform(sourcePath, platform, options = {}) {
+  const skillName = path.basename(sourcePath);
   const globalPath = await getPlatformPath(platform.id);
   const targetDir = path.join(globalPath, skillName);
 
@@ -69,7 +31,9 @@ export async function install(sourcePath, options = {}) {
       ]);
 
       if (!overwrite) {
-        console.log(chalk.red("Installation aborted."));
+        console.log(
+          chalk.red("Installation aborted for platform:", platform.name),
+        );
         return;
       }
     }
@@ -77,17 +41,117 @@ export async function install(sourcePath, options = {}) {
 
   try {
     await fs.ensureDir(globalPath);
-    await fs.copy(resolvedSource, targetDir, {
+    await fs.copy(sourcePath, targetDir, {
       filter: (src) => {
         const basename = path.basename(src);
         return basename !== "node_modules" && basename !== ".git";
       },
     });
     console.log(
-      chalk.green(`Successfully installed '${skillName}' to ${targetDir}`),
+      chalk.green(
+        `Successfully installed '${skillName}' to ${targetDir} (${platform.name})`,
+      ),
     );
   } catch (e) {
-    console.error(chalk.red(`Installation failed: ${e.message}`));
+    console.error(
+      chalk.red(`Installation failed for ${platform.name}: ${e.message}`),
+    );
+    // Don't exit, continue to next platform
+  }
+}
+
+export async function install(pathStr, options = {}) {
+  let sourcePath = pathStr;
+
+  if (!sourcePath) {
+    if (options.nonInteractive) {
+      console.error(
+        chalk.red("Error: Path is required in non-interactive mode"),
+      );
+      process.exit(1);
+    }
+
+    const skills = await findSkills(".");
+    const validSkills = skills.filter((s) => !s.error);
+
+    if (validSkills.length === 0) {
+      console.error(
+        chalk.red("Error: No valid skills detected in current directory"),
+      );
+      process.exit(1);
+      return;
+    }
+
+    if (validSkills.length === 1) {
+      sourcePath = validSkills[0].path;
+      console.log(chalk.blue(`Detected skill: ${validSkills[0].name}`));
+    } else {
+      const { selectedSkillPath } = await promptWithCancellation([
+        {
+          type: "list",
+          name: "selectedSkillPath",
+          message: "Select a skill to install:",
+          choices: validSkills.map((s) => ({
+            name: `${s.name} (${s.platform.name})`,
+            value: s.path,
+          })),
+        },
+      ]);
+      sourcePath = selectedSkillPath;
+    }
+  }
+
+  const resolvedSource = path.resolve(sourcePath);
+  if (!(await fs.pathExists(resolvedSource))) {
+    console.error(
+      chalk.red(`Error: Source path ${resolvedSource} does not exist`),
+    );
     process.exit(1);
+    return;
+  }
+
+  let selectedPlatforms = [];
+  if (options.platform) {
+    const platform = platforms[options.platform];
+    if (!platform) {
+      console.error(chalk.red(`Error: Unknown platform '${options.platform}'`));
+      process.exit(1);
+    }
+    selectedPlatforms = [platform];
+  } else {
+    let detectedPlatformId = null;
+    const skillMdPath = path.join(resolvedSource, "SKILL.md");
+    if (await fs.pathExists(skillMdPath)) {
+      const skills = await findSkills(path.dirname(resolvedSource));
+      const currentSkill = skills.find((s) => s.path === resolvedSource);
+      if (currentSkill) {
+        detectedPlatformId = currentSkill.platform.id;
+      }
+    }
+
+    const answers = await promptWithCancellation([
+      {
+        type: "list",
+        name: "platform",
+        message: "Select target platform to install to:",
+        default: detectedPlatformId,
+        choices: [
+          ...Object.values(platforms).map((p) => ({
+            name: p.name,
+            value: p.id,
+          })),
+          { name: "ALL platforms", value: "all" },
+        ],
+      },
+    ]);
+    if (answers.platform === "all") {
+      selectedPlatforms = Object.values(platforms);
+    } else {
+      selectedPlatforms = [platforms[answers.platform]];
+    }
+  }
+
+  for (const platform of selectedPlatforms) {
+    await installToPlatform(resolvedSource, platform, options);
   }
 }

package/src/commands/platforms.js

@@ -0,0 +1,10 @@
+import chalk from "chalk";
+import { platforms } from "../platforms/index.js";
+
+export async function platformsCommand(options = {}) {
+  console.log(chalk.blue("Available Platforms:\n"));
+
+  for (const [id, platform] of Object.entries(platforms)) {
+    console.log(`${chalk.bold(id)}: ${platform.name}`);
+  }
+}

package/src/commands/uninstall.js

@@ -3,114 +3,135 @@ import path from "path";
 import chalk from "chalk";
 import { platforms, getPlatform, getPlatformPath } from "../platforms/index.js";
 import { promptWithCancellation } from "../utils/prompt.js";
+import { getAllInstalledSkills } from "../utils/skills.js";
+
+async function uninstallSkill(targetPath, options = {}) {
+  try {
+    await fs.remove(targetPath);
+    console.log(chalk.green(`Successfully removed skill from ${targetPath}`));
+  } catch (e) {
+    console.error(chalk.red(`Error removing skill: ${e.message}`));
+  }
+}
 
 export async function uninstall(name, options = {}) {
-  // If name is not provided, try to infer from current directory
   let skillName = name;
-  let targetPath;
-  let platform;
+  let targetPaths = [];
 
   if (!skillName) {
-    // Check if current directory is a skill
-    const skillMdPath = path.join(process.cwd(), "SKILL.md");
-    if (await fs.pathExists(skillMdPath)) {
-      skillName = path.basename(process.cwd());
-      targetPath = process.cwd();
-      console.log(
-        chalk.blue(`Detected skill '${skillName}' in current directory.`),
+    if (options.nonInteractive) {
+      console.error(
+        chalk.red("Error: Skill name is required in non-interactive mode."),
       );
-    } else {
-      console.error(chalk.red("Error: Skill name is required."));
       process.exit(1);
+      return;
     }
-  }
 
-  // If platform is provided, look in that platform's global path
-  if (options.platform) {
-    platform = getPlatform(options.platform);
-    if (!platform) {
-      console.error(chalk.red(`Error: Unknown platform '${options.platform}'`));
+    const allSkills = await getAllInstalledSkills();
+    if (allSkills.length === 0) {
+      console.error(chalk.red("Error: No installed skills found."));
       process.exit(1);
+      return;
     }
 
-    const globalPath = path.join(platform.defaultPath, skillName);
-    if (await fs.pathExists(globalPath)) {
-      targetPath = globalPath;
-    }
-  }
+    const { selectedSkills } = await promptWithCancellation([
+      {
+        type: "checkbox",
+        name: "selectedSkills",
+        message: "Select skills to uninstall:",
+        choices: allSkills.map((s) => ({
+          name: `${chalk.bold(s.name)} [${s.platform.name}] (${s.location}) - ${s.description}`,
+          value: s.path,
+        })),
+        validate: (input) =>
+          input.length > 0 ? true : "You must select at least one skill.",
+      },
+    ]);
+
+    targetPaths = selectedSkills;
+  } else {
+    let targetPath;
+    if (options.platform) {
+      const platform = getPlatform(options.platform);
+      if (!platform) {
+        console.error(
+          chalk.red(`Error: Unknown platform '${options.platform}'`),
+        );
+        process.exit(1);
+      }
 
-  // If we still don't have a target path, search in all platforms globally or check local project structure
-  if (!targetPath) {
-    // Search in all global locations
-    const found = [];
-    for (const p of Object.values(platforms)) {
-      const globalPath = await getPlatformPath(p.id);
+      const globalPath = await getPlatformPath(platform.id);
       const pPath = path.join(globalPath, skillName);
       if (await fs.pathExists(pPath)) {
-        found.push({ platform: p, path: pPath, location: "Global" });
+        targetPath = pPath;
       }
     }
 
-    // Check current directory if we didn't start there
-    if (await fs.pathExists(path.join(process.cwd(), "SKILL.md"))) {
-      // Check if name matches
-      // Logic is tricky if user provides name but we are in a folder.
-      // Assuming user provided name implies searching for it.
-    }
+    if (!targetPath) {
+      const found = [];
+      for (const p of Object.values(platforms)) {
+        const globalPath = await getPlatformPath(p.id);
+        const pPath = path.join(globalPath, skillName);
+        if (await fs.pathExists(pPath)) {
+          found.push({ platform: p, path: pPath, location: "Global" });
+        }
 
-    // Also check project local folders like .claude/skills/name
-    for (const p of Object.values(platforms)) {
-      const localBase =
-        p.id === "opencode" ? ".opencode/skill" : `.${p.id}/skills`;
-      const localPath = path.join(process.cwd(), localBase, skillName);
-      if (await fs.pathExists(localPath)) {
-        found.push({ platform: p, path: localPath, location: "Project" });
+        const localBase =
+          p.id === "opencode" ? ".opencode/skill" : `.${p.id}/skills`;
+        const localPath = path.join(process.cwd(), localBase, skillName);
+        if (await fs.pathExists(localPath)) {
+          found.push({ platform: p, path: localPath, location: "Project" });
+        }
       }
-    }
 
-    if (found.length === 0) {
-      console.error(chalk.red(`Error: Skill '${skillName}' not found.`));
-      process.exit(1);
-    } else if (found.length === 1) {
-      targetPath = found[0].path;
-      console.log(
-        chalk.blue(
-          `Found skill in ${found[0].platform.name} (${found[0].location})`,
-        ),
-      );
-    } else {
-      // Multiple found, ask user
-      if (options.nonInteractive) {
-        console.error(
-          chalk.red(
-            `Error: Multiple skills found with name '${skillName}'. Specify --platform or use interactive mode.`,
-          ),
-        );
+      if (found.length === 0) {
+        console.error(chalk.red(`Error: Skill '${skillName}' not found.`));
         process.exit(1);
+      } else if (found.length === 1) {
+        targetPath = found[0].path;
+      } else {
+        if (options.nonInteractive) {
+          console.error(
+            chalk.red(
+              `Error: Multiple skills found with name '${skillName}'. Specify --platform or use interactive mode.`,
+            ),
+          );
+          process.exit(1);
+        }
+
+        const answer = await promptWithCancellation([
+          {
+            type: "list",
+            name: "target",
+            message: "Multiple skills found. Which one to uninstall?",
+            choices: [
+              ...found.map((f) => ({
+                name: `${f.platform.name} (${f.location}) - ${f.path}`,
+                value: f.path,
+              })),
+              { name: "ALL skills", value: "all" },
+            ],
+          },
+        ]);
+        if (answer.target === "all") {
+          targetPaths = found.map((f) => f.path);
+        } else {
+          targetPath = answer.target;
+        }
       }
+    }
 
-      const answer = await promptWithCancellation([
-        {
-          type: "list",
-          name: "target",
-          message: "Multiple skills found. Which one to uninstall?",
-          choices: found.map((f) => ({
-            name: `${f.platform.name} (${f.location}) - ${f.path}`,
-            value: f.path,
-          })),
-        },
-      ]);
-      targetPath = answer.target;
+    if (targetPath) {
+      targetPaths = [targetPath];
     }
   }
 
-  // Confirm deletion
-  if (!options.nonInteractive) {
+  if (targetPaths.length > 0 && !options.nonInteractive) {
     const { confirm } = await promptWithCancellation([
       {
         type: "confirm",
         name: "confirm",
-        message: `Are you sure you want to delete ${targetPath}? This cannot be undone.`,
+        message: `Are you sure you want to delete ${targetPaths.length} skill(s)? This cannot be undone.`,
         default: false,
       },
     ]);
@@ -121,11 +142,7 @@ export async function uninstall(name, options = {}) {
     }
   }
 
-  try {
-    await fs.remove(targetPath);
-    console.log(chalk.green(`Successfully removed skill from ${targetPath}`));
-  } catch (e) {
-    console.error(chalk.red(`Error removing skill: ${e.message}`));
-    process.exit(1);
+  for (const p of targetPaths) {
+    await uninstallSkill(p, options);
   }
 }

package/src/utils/skills.js

@@ -0,0 +1,101 @@
+import fs from "fs-extra";
+import path from "path";
+import yaml from "js-yaml";
+import { platforms, getPlatformPath } from "../platforms/index.js";
+
+export function detectPlatform(frontmatter) {
+  if (
+    frontmatter["allowed-tools"] ||
+    frontmatter.context ||
+    frontmatter.hooks ||
+    frontmatter.agent ||
+    frontmatter["user-invocable"]
+  ) {
+    return platforms.claude;
+  }
+
+  if (frontmatter.license || frontmatter.compatibility) {
+    return platforms.opencode;
+  }
+
+  if (frontmatter.metadata && frontmatter.metadata["short-description"]) {
+    return platforms.codex;
+  }
+
+  return platforms.gemini;
+}
+
+export async function findSkills(dirPath) {
+  const targetDir = path.resolve(dirPath);
+  if (!(await fs.pathExists(targetDir))) return [];
+  const items = await fs.readdir(targetDir, { withFileTypes: true });
+  const skills = [];
+
+  for (const item of items) {
+    if (item.isDirectory()) {
+      const skillPath = path.join(targetDir, item.name, "SKILL.md");
+      if (await fs.pathExists(skillPath)) {
+        try {
+          const content = await fs.readFile(skillPath, "utf8");
+          const match = content.match(/^---\n([\s\S]*?)\n---/);
+
+          if (!match) {
+            skills.push({
+              name: item.name,
+              path: path.join(targetDir, item.name),
+              error: "Invalid frontmatter format",
+            });
+            continue;
+          }
+
+          const fm = yaml.load(match[1]);
+          const platform = detectPlatform(fm);
+          const description = fm.description || "No description";
+
+          skills.push({
+            name: item.name,
+            path: path.join(targetDir, item.name),
+            platform,
+            description,
+            valid: true,
+          });
+        } catch (e) {
+          skills.push({
+            name: item.name,
+            path: path.join(targetDir, item.name),
+            error: "Read error",
+          });
+        }
+      }
+    }
+  }
+
+  return skills;
+}
+
+export async function getAllInstalledSkills() {
+  const allSkills = [];
+  for (const platform of Object.values(platforms)) {
+    const globalPath = await getPlatformPath(platform.id);
+    const localBase =
+      platform.id === "opencode" ? ".opencode/skill" : `.${platform.id}/skills`;
+    const locations = [
+      { name: "Global", path: globalPath },
+      { name: "Project", path: path.join(process.cwd(), localBase) },
+    ];
+
+    for (const loc of locations) {
+      if (await fs.pathExists(loc.path)) {
+        const skills = await findSkills(loc.path);
+        for (const skill of skills) {
+          allSkills.push({
+            ...skill,
+            platform,
+            location: loc.name,
+          });
+        }
+      }
+    }
+  }
+  return allSkills;
+}