myskill 1.0.0

package/src/commands/uninstall.js

@@ -0,0 +1,131 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import { platforms, getPlatform, getPlatformPath } from "../platforms/index.js";
+import { promptWithCancellation } from "../utils/prompt.js";
+
+export async function uninstall(name, options = {}) {
+  // If name is not provided, try to infer from current directory
+  let skillName = name;
+  let targetPath;
+  let platform;
+
+  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.`),
+      );
+    } else {
+      console.error(chalk.red("Error: Skill name is required."));
+      process.exit(1);
+    }
+  }
+
+  // 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}'`));
+      process.exit(1);
+    }
+
+    const globalPath = path.join(platform.defaultPath, skillName);
+    if (await fs.pathExists(globalPath)) {
+      targetPath = globalPath;
+    }
+  }
+
+  // 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 pPath = path.join(globalPath, skillName);
+      if (await fs.pathExists(pPath)) {
+        found.push({ platform: p, path: pPath, location: "Global" });
+      }
+    }
+
+    // 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.
+    }
+
+    // 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" });
+      }
+    }
+
+    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.`,
+          ),
+        );
+        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,
+          })),
+        },
+      ]);
+      targetPath = answer.target;
+    }
+  }
+
+  // Confirm deletion
+  if (!options.nonInteractive) {
+    const { confirm } = await promptWithCancellation([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `Are you sure you want to delete ${targetPath}? This cannot be undone.`,
+        default: false,
+      },
+    ]);
+
+    if (!confirm) {
+      console.log(chalk.yellow("Aborted."));
+      return;
+    }
+  }
+
+  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);
+  }
+}

package/src/commands/validate.js

@@ -0,0 +1,87 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import yaml from "js-yaml";
+import { platforms } from "../platforms/index.js";
+
+export async function validate(targetPath, options = {}) {
+  const resolvedPath = path.resolve(targetPath);
+  const skillMdPath = path.join(resolvedPath, "SKILL.md");
+
+  if (!(await fs.pathExists(skillMdPath))) {
+    console.error(chalk.red(`Error: SKILL.md not found in ${resolvedPath}`));
+    process.exit(1);
+  }
+
+  const content = await fs.readFile(skillMdPath, "utf8");
+
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    console.error(
+      chalk.red("Error: Invalid front matter format (missing --- fences)"),
+    );
+    process.exit(1);
+  }
+
+  let frontMatter;
+  try {
+    frontMatter = yaml.load(match[1]);
+  } catch (e) {
+    console.error(chalk.red(`Error: YAML parsing failed: ${e.message}`));
+    process.exit(1);
+  }
+
+  let targetPlatforms = [];
+  if (options.platform) {
+    if (platforms[options.platform]) {
+      targetPlatforms.push(platforms[options.platform]);
+    } else {
+      console.error(chalk.red(`Error: Unknown platform '${options.platform}'`));
+      process.exit(1);
+    }
+  } else {
+    targetPlatforms = Object.values(platforms);
+  }
+
+  let successCount = 0;
+  const errors = [];
+
+  for (const platform of targetPlatforms) {
+    try {
+      platform.schema.parse(frontMatter);
+      const dirName = path.basename(resolvedPath);
+      if (frontMatter.name !== dirName) {
+        throw new Error(
+          `Directory name '${dirName}' does not match skill name '${frontMatter.name}'`,
+        );
+      }
+
+      console.log(chalk.green(`✓ Valid ${platform.name} skill`));
+      successCount++;
+    } catch (e) {
+      if (options.platform) {
+        if (e.errors) {
+          e.errors.forEach((err) => {
+            errors.push(
+              `[${platform.name}] ${err.path.join(".")}: ${err.message}`,
+            );
+          });
+        } else {
+          errors.push(`[${platform.name}] ${e.message}`);
+        }
+      }
+    }
+  }
+
+  if (successCount === 0) {
+    console.error(chalk.red("Validation Failed:"));
+    if (errors.length > 0) {
+      errors.forEach((e) => console.error(chalk.red(e)));
+    } else {
+      console.error(
+        chalk.red("Skill does not match any known platform schema."),
+      );
+    }
+    process.exit(1);
+  }
+}

package/src/platforms/claude.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import path from "path";
+import os from "os";
+import { getConfig } from "../utils/config.js";
+
+// We need to make this async or a function to read config
+// But index.js exports static objects.
+// Let's change the platforms to be functions or getters?
+// This is a breaking change for internal architecture.
+// Or we can load config synchronously? No, fs-extra is async.
+// Best approach: Keep the export structure but make defaultPath a getter or load it once at startup.
+// Since `bin/myskill.js` is async, we can initialize platforms there?
+// Or just reading config synchronously if we must?
+// Node.js supports top-level await in modules.
+
+// Let's try top-level await for config loading since we are in ESM.
+let config = {};
+try {
+  // We can't easily do top level await here without fs/promises and maybe it slows down startup.
+  // Instead, let's make `defaultPath` a property we resolve when needed, or check config inside commands.
+  // BUT the prompt definitions and validation logic depend on platform definition.
+  // The path is mostly used in commands (create, list, etc).
+  // So let's change `defaultPath` to a function `getDefaultPath()`.
+} catch (e) {}
+
+// For now, I will modify the definitions to export functions or include a resolution helper.
+// Actually, simplest is to just expose the hardcoded default as fallback,
+// and utility function `getPlatformPath(platformId)` in `utils/config.js` or `platforms/index.js`.
+
+export const claude = {
+  id: "claude",
+  name: "Claude Code",
+  defaultPath: path.join(os.homedir(), ".claude", "skills"),
+  schema: z.object({
+    name: z
+      .string()
+      .min(1)
+      .max(64)
+      .regex(
+        /^[a-z0-9-]+$/,
+        "Name must be lowercase alphanumeric with hyphens",
+      ),
+    description: z.string().min(1).max(1024),
+    "allowed-tools": z.union([z.string(), z.array(z.string())]).optional(),
+    model: z.string().optional(),
+    context: z.enum(["fork"]).optional(),
+    agent: z.string().optional(),
+    hooks: z.any().optional(),
+    "user-invocable": z.boolean().optional(),
+  }),
+  prompts: [
+    {
+      type: "confirm",
+      name: "restrictTools",
+      message: "Do you want to restrict allowed tools?",
+      default: false,
+    },
+    {
+      type: "input",
+      name: "allowedTools",
+      message: "Enter allowed tools (comma separated):",
+      when: (answers) => answers.restrictTools,
+      filter: (input) =>
+        input
+          .split(",")
+          .map((s) => s.trim())
+          .filter(Boolean),
+    },
+  ],
+};

package/src/platforms/codex.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import path from "path";
+import os from "os";
+
+export const codex = {
+  id: "codex",
+  name: "OpenAI Codex",
+  defaultPath: path.join(os.homedir(), ".codex", "skills"),
+  schema: z.object({
+    name: z.string().min(1),
+    description: z.string().min(1),
+    metadata: z
+      .object({
+        "short-description": z.string().optional(),
+      })
+      .optional(),
+  }),
+  prompts: [
+    {
+      type: "input",
+      name: "shortDescription",
+      message: "Short description (for UI):",
+    },
+  ],
+};

package/src/platforms/gemini.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import path from "path";
+import os from "os";
+
+export const gemini = {
+  id: "gemini",
+  name: "Gemini CLI",
+  defaultPath: path.join(os.homedir(), ".gemini", "skills"),
+  schema: z.object({
+    name: z
+      .string()
+      .regex(
+        /^[a-z0-9-]+$/,
+        "Name must be lowercase alphanumeric with hyphens",
+      ),
+    description: z.string().min(1),
+  }),
+  prompts: [],
+};

package/src/platforms/index.js

@@ -0,0 +1,27 @@
+import { claude } from "./claude.js";
+import { opencode } from "./opencode.js";
+import { codex } from "./codex.js";
+import { gemini } from "./gemini.js";
+import { getConfig } from "../utils/config.js";
+
+export const platforms = {
+  claude,
+  opencode,
+  codex,
+  gemini,
+};
+
+export function getPlatform(id) {
+  return platforms[id];
+}
+
+export async function getPlatformPath(id) {
+  const platform = platforms[id];
+  if (!platform) return null;
+
+  const config = await getConfig();
+  if (config[id] && config[id].path) {
+    return config[id].path;
+  }
+  return platform.defaultPath;
+}

package/src/platforms/opencode.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import path from "path";
+import os from "os";
+
+export const opencode = {
+  id: "opencode",
+  name: "OpenCode",
+  defaultPath: path.join(os.homedir(), ".config", "opencode", "skill"),
+  schema: z.object({
+    name: z
+      .string()
+      .min(1)
+      .max(64)
+      .regex(
+        /^[a-z0-9]+(-[a-z0-9]+)*$/,
+        "Name must be lowercase alphanumeric, single hyphens only, no start/end hyphen",
+      ),
+    description: z.string().min(1).max(1024),
+    license: z.string().optional(),
+    compatibility: z.string().optional(),
+    metadata: z.record(z.string()).optional(),
+  }),
+  prompts: [
+    {
+      type: "input",
+      name: "license",
+      message: "License (e.g., MIT):",
+    },
+    {
+      type: "input",
+      name: "compatibility",
+      message: "Compatibility (e.g., opencode):",
+      default: "opencode",
+    },
+  ],
+};

package/src/templates/generateSkill.js

@@ -0,0 +1,20 @@
+import yaml from "js-yaml";
+
+export function generateSkill(frontMatter, content) {
+  const yamlStr = yaml.dump(frontMatter, { lineWidth: -1 });
+  const defaultContent =
+    content ||
+    `# ${frontMatter.name}
+
+## Instructions
+Provide clear, step-by-step guidance for the agent here.
+
+## Examples
+Show concrete examples of using this skill.
+`;
+
+  return `---
+${yamlStr}---
+
+${defaultContent}`;
+}

package/src/utils/config.js

@@ -0,0 +1,41 @@
+import fs from "fs-extra";
+import path from "path";
+import os from "os";
+
+const CONFIG_PATH = path.join(
+  os.homedir(),
+  ".config",
+  "myskill",
+  "config.json",
+);
+
+export async function getConfig() {
+  if (await fs.pathExists(CONFIG_PATH)) {
+    try {
+      return await fs.readJson(CONFIG_PATH);
+    } catch (e) {
+      return {};
+    }
+  }
+  return {};
+}
+
+export async function setConfig(key, value) {
+  const config = await getConfig();
+
+  // Handle nested keys like "claude.path"
+  const keys = key.split(".");
+  let current = config;
+
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = keys[i];
+    if (!current[k]) current[k] = {};
+    current = current[k];
+  }
+
+  current[keys[keys.length - 1]] = value;
+
+  await fs.ensureDir(path.dirname(CONFIG_PATH));
+  await fs.writeJson(CONFIG_PATH, config, { spaces: 2 });
+  return config;
+}

package/src/utils/prompt.js

@@ -0,0 +1,66 @@
+import inquirer from "inquirer";
+import readline from "readline";
+
+/**
+ * Wrapper for inquirer.prompt that handles cancellation gracefully
+ * Allows both Ctrl+C and Escape key to cancel prompts
+ * @param {Array} questions - Array of question objects for inquirer
+ * @returns {Promise<Object>} - Resolves with answers or throws on cancellation
+ */
+export async function promptWithCancellation(questions) {
+  // Create a promise that can be rejected on Escape key
+  let cleanup = () => {}; // Placeholder for cleanup function
+
+  const escapePromise = new Promise((_, reject) => {
+    // Enable keypress events on stdin
+    readline.emitKeypressEvents(process.stdin);
+
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+
+    const onKeypress = (str, key) => {
+      if (key && key.name === "escape") {
+        process.stdin.off("keypress", onKeypress);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        reject(new Error("ESCAPE_PRESSED"));
+      }
+    };
+
+    process.stdin.on("keypress", onKeypress);
+
+    // Set up cleanup function
+    cleanup = () => {
+      process.stdin.off("keypress", onKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+    };
+  });
+
+  // Clean up the listener when the promise is settled
+  escapePromise.finally(cleanup);
+
+  try {
+    // Race between the prompt and escape key detection
+    const answers = await Promise.race([
+      inquirer.prompt(questions),
+      escapePromise,
+    ]);
+    return answers;
+  } catch (error) {
+    // Handle both Inquirer cancellation and our custom Escape handling
+    if (
+      error.message === "ESCAPE_PRESSED" ||
+      error.isTtyError ||
+      error.message.includes("cancelled") ||
+      error.name === "ExitPromptError"
+    ) {
+      console.log("\nOperation cancelled.");
+      process.exit(0);
+    }
+    throw error;
+  }
+}