myskill 1.0.0

package/src/commands/create.js

@@ -0,0 +1,204 @@
+import chalk from "chalk";
+import path from "path";
+import fs from "fs-extra";
+import { format } from "prettier";
+import { platforms, getPlatform, getPlatformPath } from "../platforms/index.js";
+import { generateSkill } from "../templates/generateSkill.js";
+import { promptWithCancellation } from "../utils/prompt.js";
+
+export async function create(options = {}) {
+  let answers = { ...options };
+
+  if (!options.nonInteractive) {
+    console.log(chalk.blue("Interactive Skill Creator"));
+
+    // Step 1: Platform Selection
+    if (!answers.platform) {
+      const platformAnswer = await promptWithCancellation([
+        {
+          type: "list",
+          name: "platform",
+          message: "Select target platform:",
+          choices: Object.values(platforms).map((p) => ({
+            name: p.name,
+            value: p.id,
+          })),
+        },
+      ]);
+      answers.platform = platformAnswer.platform;
+    }
+
+    const platformConfig = getPlatform(answers.platform);
+    if (!platformConfig) {
+      console.error(chalk.red(`Error: Unknown platform '${answers.platform}'`));
+      return;
+    }
+
+    // Helper validation function using Zod schema
+    const validateField = (field, value) => {
+      const schema = platformConfig.schema.shape[field];
+      if (!schema) return true; // No validation defined
+      const result = schema.safeParse(value);
+      if (result.success) return true;
+      return result.error.issues[0].message;
+    };
+
+    // Step 2: Name & Description & Scope
+    const remainingPrompts = [];
+    if (!answers.name) {
+      remainingPrompts.push({
+        type: "input",
+        name: "name",
+        message: "Skill Name:",
+        validate: (input) => validateField("name", input),
+      });
+    }
+
+    if (!answers.description) {
+      remainingPrompts.push({
+        type: "input",
+        name: "description",
+        message: "Description:",
+        validate: (input) => validateField("description", input),
+      });
+    }
+
+    if (!answers.scope) {
+      remainingPrompts.push({
+        type: "list",
+        name: "scope",
+        message: "Where to create the skill?",
+        choices: [
+          { name: "Current Directory (Project)", value: "project" },
+          { name: "Global Skills Directory", value: "global" },
+        ],
+      });
+    }
+
+    // Platform specific prompts
+    if (platformConfig.prompts && platformConfig.prompts.length > 0) {
+      remainingPrompts.push(...platformConfig.prompts);
+    }
+
+    const interactiveAnswers = await promptWithCancellation(remainingPrompts);
+    answers = { ...answers, ...interactiveAnswers };
+  } else {
+    // Non-interactive validation
+    if (!answers.platform || !answers.name || !answers.description) {
+      console.error(
+        chalk.red(
+          "Error: --platform, --name, and --description are required in non-interactive mode.",
+        ),
+      );
+      if (process.env.NODE_ENV !== "test") process.exit(1);
+      else {
+        process.exit(1);
+        return;
+      }
+    }
+
+    const platformConfig = getPlatform(answers.platform);
+    if (!platformConfig) {
+      console.error(chalk.red(`Error: Unknown platform '${answers.platform}'`));
+      if (process.env.NODE_ENV !== "test") process.exit(1);
+      else {
+        process.exit(1);
+        return;
+      }
+    }
+
+    // Validate using schema
+    const result = platformConfig.schema.safeParse({
+      name: answers.name,
+      description: answers.description,
+      ...answers, // includes platform specific flags if any passed? Command options don't map 1:1 to flags yet except name/desc
+    });
+
+    if (!result.success) {
+      console.error(chalk.red("Validation Error:"));
+      result.error.issues.forEach((issue) => {
+        console.error(chalk.red(`- ${issue.path.join(".")}: ${issue.message}`));
+      });
+      if (process.env.NODE_ENV !== "test") process.exit(1);
+      else {
+        process.exit(1);
+        return;
+      }
+    }
+  }
+
+  // Construct Front Matter
+  // Filter out internal keys
+  const internalKeys = ["scope", "platform", "nonInteractive"];
+  const frontMatter = {};
+
+  // We need to merge answers into frontMatter, but ONLY fields that belong to the schema
+  // or platform specific prompts.
+  // Easiest way: take everything from answers that isn't internal.
+
+  for (const [key, value] of Object.entries(answers)) {
+    if (!internalKeys.includes(key)) {
+      frontMatter[key] = value;
+    }
+  }
+
+  // Specific cleanup
+  if (frontMatter.restrictTools !== undefined) delete frontMatter.restrictTools;
+  if (frontMatter.allowedTools && frontMatter.allowedTools.length === 0)
+    delete frontMatter.allowedTools;
+  // Also delete confirm if present from previous implementation logic, though here we moved it
+  if (frontMatter.confirm !== undefined) delete frontMatter.confirm;
+
+  const platformConfig = getPlatform(answers.platform); // get again to be safe
+
+  let fileContent = generateSkill(frontMatter);
+
+  // Format with Prettier
+  try {
+    fileContent = await format(fileContent, { parser: "markdown" });
+  } catch (e) {
+    // Ignore formatting errors, fallback to raw content
+  }
+
+  let targetDir;
+  if (answers.scope === "global") {
+    const globalPath = await getPlatformPath(answers.platform);
+    targetDir = path.join(globalPath, answers.name);
+  } else {
+    const localBase =
+      answers.platform === "opencode"
+        ? ".opencode/skill"
+        : `.${answers.platform}/skills`;
+    targetDir = path.join(process.cwd(), localBase, answers.name);
+  }
+
+  if (!options.nonInteractive) {
+    console.log(chalk.yellow(`\nAbout to create skill at: ${targetDir}`));
+    console.log(chalk.gray(fileContent));
+
+    const { confirm } = await promptWithCancellation([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Proceed?",
+        default: true,
+      },
+    ]);
+
+    if (!confirm) {
+      console.log(chalk.red("Aborted."));
+      return;
+    }
+  }
+
+  try {
+    await fs.ensureDir(targetDir);
+    await fs.writeFile(path.join(targetDir, "SKILL.md"), fileContent);
+    await fs.ensureDir(path.join(targetDir, "scripts"));
+    console.log(chalk.green(`Skill created successfully at ${targetDir}`));
+  } catch (error) {
+    console.error(chalk.red(`Error creating skill: ${error.message}`));
+    if (process.env.NODE_ENV !== "test") process.exit(1);
+    else process.exit(1);
+  }
+}

package/src/commands/doctor.js

@@ -0,0 +1,60 @@
+import chalk from "chalk";
+import fs from "fs-extra";
+import path from "path";
+import simpleGit from "simple-git";
+import { platforms, getPlatformPath } from "../platforms/index.js";
+import { getConfig } from "../utils/config.js";
+
+export async function doctor() {
+  console.log(chalk.bold("Running diagnostics..."));
+  console.log("");
+
+  let issues = 0;
+
+  // 1. Check Git
+  try {
+    const git = simpleGit();
+    const version = await git.raw(["--version"]);
+    console.log(`${chalk.green("✓")} Git installed: ${version.trim()}`);
+  } catch (e) {
+    console.log(`${chalk.red("✗")} Git not found or error: ${e.message}`);
+    issues++;
+  }
+
+  // 2. Check Platform Directories
+  for (const platform of Object.values(platforms)) {
+    const pPath = await getPlatformPath(platform.id);
+    try {
+      await fs.ensureDir(pPath);
+      // Check write access
+      const testFile = path.join(pPath, ".write-test");
+      await fs.writeFile(testFile, "test");
+      await fs.remove(testFile);
+      console.log(
+        `${chalk.green("✓")} ${platform.name} directory writable: ${pPath}`,
+      );
+    } catch (e) {
+      console.log(
+        `${chalk.red("✗")} ${platform.name} directory issue: ${e.message}`,
+      );
+      issues++;
+    }
+  }
+
+  // 3. Check Config
+  try {
+    const config = await getConfig();
+    console.log(`${chalk.green("✓")} Config loaded: ${JSON.stringify(config)}`);
+  } catch (e) {
+    console.log(`${chalk.red("✗")} Config load error: ${e.message}`);
+    issues++;
+  }
+
+  console.log("");
+  if (issues === 0) {
+    console.log(chalk.green("All checks passed!"));
+  } else {
+    console.log(chalk.yellow(`Found ${issues} issues.`));
+    // Don't exit with error code, just report
+  }
+}

package/src/commands/find.js

@@ -0,0 +1,108 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import yaml from "js-yaml";
+import Fuse from "fuse.js";
+import { platforms, getPlatformPath } from "../platforms/index.js";
+
+export async function find(query, options = {}) {
+  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);
+  }
+
+  const allSkills = [];
+
+  // Gather skills
+  for (const platform of targetPlatforms) {
+    const globalPath = await getPlatformPath(platform.id);
+    const locations = [{ name: "Global", path: globalPath, type: "global" }];
+
+    const localBase =
+      platform.id === "opencode" ? ".opencode/skill" : `.${platform.id}/skills`;
+    locations.push({
+      name: "Project",
+      path: path.join(process.cwd(), localBase),
+      type: "project",
+    });
+
+    for (const loc of locations) {
+      if (await fs.pathExists(loc.path)) {
+        try {
+          const items = await fs.readdir(loc.path, { withFileTypes: true });
+          for (const item of items) {
+            if (item.isDirectory()) {
+              const skillPath = path.join(loc.path, 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) {
+                    const fm = yaml.load(match[1]);
+                    allSkills.push({
+                      name: fm.name || item.name,
+                      description: fm.description || "",
+                      platform: platform.name,
+                      platformId: platform.id,
+                      location: loc.name,
+                      path: skillPath,
+                    });
+                  }
+                } catch (e) {
+                  // Ignore read errors
+                }
+              }
+            }
+          }
+        } catch (e) {
+          // Ignore readdir errors
+        }
+      }
+    }
+  }
+
+  if (allSkills.length === 0) {
+    console.log(chalk.yellow("No skills found."));
+    return;
+  }
+
+  let results = allSkills;
+
+  if (query) {
+    const fuse = new Fuse(allSkills, {
+      keys: ["name", "description"],
+      threshold: 0.4, // Fuzzy threshold (0.0 = exact match, 1.0 = match anything)
+      includeScore: true,
+    });
+    results = fuse.search(query).map((r) => r.item);
+  }
+
+  // Display results
+  if (results.length === 0) {
+    console.log(chalk.yellow(`No skills matched query '${query}'`));
+    return;
+  }
+
+  console.log(chalk.bold(`Found ${results.length} skills:`));
+  console.log("------------------------------------------------");
+
+  // Group by platform for cleaner output? Or just list.
+  // List seems better for search results.
+
+  results.forEach((skill) => {
+    console.log(
+      `${chalk.green(skill.name)} ${chalk.gray(`[${skill.platform} | ${skill.location}]`)}`,
+    );
+    if (skill.description) {
+      console.log(`  ${skill.description}`);
+    }
+    console.log("");
+  });
+}

package/src/commands/install.js

@@ -0,0 +1,93 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import { platforms, getPlatformPath } from "../platforms/index.js";
+import { promptWithCancellation } from "../utils/prompt.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);
+  const globalPath = await getPlatformPath(platform.id);
+  const targetDir = path.join(globalPath, skillName);
+
+  if (await fs.pathExists(targetDir)) {
+    if (options.force) {
+      // Continue
+    } else if (options.nonInteractive) {
+      console.error(
+        chalk.red(
+          `Error: Skill already exists at ${targetDir}. Use --force to overwrite.`,
+        ),
+      );
+      process.exit(1);
+    } else {
+      const { overwrite } = await promptWithCancellation([
+        {
+          type: "confirm",
+          name: "overwrite",
+          message: `Skill '${skillName}' already exists in ${platform.name} global directory. Overwrite?`,
+          default: false,
+        },
+      ]);
+
+      if (!overwrite) {
+        console.log(chalk.red("Installation aborted."));
+        return;
+      }
+    }
+  }
+
+  try {
+    await fs.ensureDir(globalPath);
+    await fs.copy(resolvedSource, targetDir, {
+      filter: (src) => {
+        const basename = path.basename(src);
+        return basename !== "node_modules" && basename !== ".git";
+      },
+    });
+    console.log(
+      chalk.green(`Successfully installed '${skillName}' to ${targetDir}`),
+    );
+  } catch (e) {
+    console.error(chalk.red(`Installation failed: ${e.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/list.js

@@ -0,0 +1,60 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import yaml from "js-yaml";
+import { platforms, getPlatformPath } from "../platforms/index.js";
+
+export async function list(options = {}) {
+  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);
+  }
+
+  for (const platform of targetPlatforms) {
+    console.log(chalk.blue(`\n=== ${platform.name} Skills ===`));
+
+    const globalPath = await getPlatformPath(platform.id);
+    const locations = [{ name: "Global", path: globalPath }];
+
+    const localBase =
+      platform.id === "opencode" ? ".opencode/skill" : `.${platform.id}/skills`;
+    locations.push({
+      name: "Project",
+      path: path.join(process.cwd(), localBase),
+    });
+
+    for (const loc of locations) {
+      if (await fs.pathExists(loc.path)) {
+        const items = await fs.readdir(loc.path, { withFileTypes: true });
+        for (const item of items) {
+          if (item.isDirectory()) {
+            const skillPath = path.join(loc.path, 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) {
+                  const fm = yaml.load(match[1]);
+                  console.log(
+                    `- ${chalk.bold(fm.name)} (${loc.name}): ${fm.description || "No description"}`,
+                  );
+                } else {
+                  console.log(`- ${item.name} (${loc.name}): [Invalid Format]`);
+                }
+              } catch (e) {
+                console.log(`- ${item.name} (${loc.name}): [Read Error]`);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/src/commands/pull.js

@@ -0,0 +1,93 @@
+import simpleGit from "simple-git";
+import path from "path";
+import fs from "fs-extra";
+import chalk from "chalk";
+import { platforms, getPlatform, getPlatformPath } from "../platforms/index.js";
+import { promptWithCancellation } from "../utils/prompt.js";
+
+export async function pull(repoUrl, options = {}) {
+  // Logic:
+  // 1. Identify target platform.
+  // 2. Identify target name (from repo name or option).
+  // 3. Clone or Pull.
+
+  if (!repoUrl) {
+    console.error(chalk.red("Error: Repository URL is required."));
+    process.exit(1);
+  }
+
+  let platformName = options.platform;
+  if (!platformName) {
+    // Try interactive
+    if (!options.nonInteractive) {
+      const answer = await promptWithCancellation([
+        {
+          type: "list",
+          name: "platform",
+          message: "Target platform for this skill:",
+          choices: Object.values(platforms).map((p) => ({
+            name: p.name,
+            value: p.id,
+          })),
+        },
+      ]);
+      platformName = answer.platform;
+    } else {
+      console.error(chalk.red("Error: Platform is required (--platform)."));
+      process.exit(1);
+    }
+  }
+
+  const platform = getPlatform(platformName);
+  if (!platform) {
+    console.error(chalk.red(`Error: Unknown platform '${platformName}'`));
+    process.exit(1);
+  }
+
+  // Determine skill name from repo URL if not provided
+  let skillName = options.name;
+  if (!skillName) {
+    const basename = path.basename(repoUrl, ".git");
+    skillName = basename;
+  }
+
+  // Target directory
+  const platformPath = await getPlatformPath(platformName);
+  const targetDir = path.join(platformPath, skillName);
+
+  const git = simpleGit();
+
+  // Check if git is installed
+  try {
+    await git.raw(["--version"]);
+  } catch (e) {
+    throw new Error(
+      "Git is not installed or not in PATH. Please install git to use this command.",
+    );
+  }
+
+  if (await fs.pathExists(targetDir)) {
+    // Exists, try to pull
+    console.log(
+      chalk.blue(`Skill '${skillName}' exists. Pulling latest changes...`),
+    );
+    try {
+      await git.cwd(targetDir).pull();
+      console.log(chalk.green("Successfully updated skill."));
+    } catch (e) {
+      console.error(chalk.red(`Error pulling changes: ${e.message}`));
+      process.exit(1);
+    }
+  } else {
+    // Clone
+    console.log(chalk.blue(`Cloning '${skillName}' to ${targetDir}...`));
+    try {
+      await fs.ensureDir(platformPath);
+      await git.clone(repoUrl, targetDir);
+      console.log(chalk.green("Successfully cloned skill."));
+    } catch (e) {
+      console.error(chalk.red(`Error cloning repo: ${e.message}`));
+      process.exit(1);
+    }
+  }
+}

package/src/commands/run.js

@@ -0,0 +1,83 @@
+import chalk from "chalk";
+import path from "path";
+import fs from "fs-extra";
+import { spawn } from "child_process";
+
+export async function run(skillName, args = [], options = {}) {
+  // Goal: Run the skill script.
+  // 1. Locate the skill (reuse find logic logic or simple path check).
+  // 2. Identify the entry point (e.g. scripts/run.py, scripts/index.js).
+  // 3. Execute it.
+
+  // For simplicity, let's look in current directory first, then use `uninstall`'s detection logic or similar.
+  // We'll reuse `uninstall`'s detection logic essentially? Or just rely on current dir for now as experimental.
+  // Let's implement a simple path resolver reusing what we learned.
+
+  let targetPath = path.resolve(skillName);
+
+  // If absolute path provided and exists
+  if (!(await fs.pathExists(targetPath))) {
+    // Try resolving as name in current dir
+    targetPath = path.resolve(process.cwd(), skillName);
+    if (!(await fs.pathExists(targetPath))) {
+      // TODO: Look in global paths if we want to run installed skills.
+      // For experimental runner, let's stick to local development context for now or global.
+      // Let's assume user provides path or name in current dir.
+      console.error(
+        chalk.red(`Error: Skill directory '${skillName}' not found.`),
+      );
+      process.exit(1);
+      return; // Ensure return for test mocks
+    }
+  }
+
+  // Look for entry point
+  const scriptsDir = path.join(targetPath, "scripts");
+  if (!(await fs.pathExists(scriptsDir))) {
+    console.error(
+      chalk.red(`Error: 'scripts' directory not found in ${targetPath}`),
+    );
+    process.exit(1);
+    return;
+  }
+
+  const potentialEntryPoints = [
+    { file: "index.js", cmd: "node" },
+    { file: "main.py", cmd: "python" },
+    { file: "run.py", cmd: "python" },
+    { file: "run.sh", cmd: "bash" },
+  ];
+
+  let entryPoint;
+  for (const ep of potentialEntryPoints) {
+    if (await fs.pathExists(path.join(scriptsDir, ep.file))) {
+      entryPoint = ep;
+      break;
+    }
+  }
+
+  if (!entryPoint) {
+    console.error(
+      chalk.red(
+        "Error: No supported entry point found (index.js, main.py, run.py, run.sh).",
+      ),
+    );
+    process.exit(1);
+    return;
+  }
+
+  console.log(chalk.blue(`Running ${entryPoint.file}...`));
+
+  const scriptPath = path.join(scriptsDir, entryPoint.file);
+  const child = spawn(entryPoint.cmd, [scriptPath, ...args], {
+    stdio: "inherit",
+    cwd: targetPath, // Run in skill root context? Or scripts? Usually root.
+  });
+
+  child.on("close", (code) => {
+    if (code !== 0) {
+      console.error(chalk.red(`Process exited with code ${code}`));
+      process.exit(code);
+    }
+  });
+}