@andysama/openskills 1.3.2

package/dist/cli.js

@@ -0,0 +1,732 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/list.ts
+import chalk from "chalk";
+
+// src/utils/skills.ts
+import { readFileSync, readdirSync, existsSync, statSync } from "fs";
+import { join as join2 } from "path";
+
+// src/utils/dirs.ts
+import { join } from "path";
+import { homedir } from "os";
+function getSearchDirs() {
+  return [
+    join(process.cwd(), ".agent/skills"),
+    // 1. Project universal (.agent)
+    join(homedir(), ".agent/skills"),
+    // 2. Global universal (.agent)
+    join(process.cwd(), ".claude/skills"),
+    // 3. Project claude
+    join(homedir(), ".claude/skills")
+    // 4. Global claude
+  ];
+}
+
+// src/utils/yaml.ts
+function extractYamlField(content, field) {
+  const match = content.match(new RegExp(`^${field}:\\s*(.+?)$`, "m"));
+  return match ? match[1].trim() : "";
+}
+function hasValidFrontmatter(content) {
+  return content.trim().startsWith("---");
+}
+
+// src/utils/skills.ts
+function isDirectoryOrSymlinkToDirectory(entry, parentDir) {
+  if (entry.isDirectory()) {
+    return true;
+  }
+  if (entry.isSymbolicLink()) {
+    try {
+      const fullPath = join2(parentDir, entry.name);
+      const stats = statSync(fullPath);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function findAllSkills() {
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  const dirs = getSearchDirs();
+  for (const dir of dirs) {
+    if (!existsSync(dir)) continue;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (isDirectoryOrSymlinkToDirectory(entry, dir)) {
+        if (seen.has(entry.name)) continue;
+        const skillPath = join2(dir, entry.name, "SKILL.md");
+        if (existsSync(skillPath)) {
+          const content = readFileSync(skillPath, "utf-8");
+          const isProjectLocal = dir.includes(process.cwd());
+          skills.push({
+            name: entry.name,
+            description: extractYamlField(content, "description"),
+            location: isProjectLocal ? "project" : "global",
+            path: join2(dir, entry.name)
+          });
+          seen.add(entry.name);
+        }
+      }
+    }
+  }
+  return skills;
+}
+function findSkill(skillName) {
+  const dirs = getSearchDirs();
+  for (const dir of dirs) {
+    const skillPath = join2(dir, skillName, "SKILL.md");
+    if (existsSync(skillPath)) {
+      return {
+        path: skillPath,
+        baseDir: join2(dir, skillName),
+        source: dir
+      };
+    }
+  }
+  return null;
+}
+
+// src/commands/list.ts
+function listSkills() {
+  console.log(chalk.bold("Available Skills:\n"));
+  const skills = findAllSkills();
+  if (skills.length === 0) {
+    console.log("No skills installed.\n");
+    console.log("Install skills:");
+    console.log(`  ${chalk.cyan("openskills install anthropics/skills")}         ${chalk.dim("# Project (default)")}`);
+    console.log(`  ${chalk.cyan("openskills install owner/skill --global")}     ${chalk.dim("# Global (advanced)")}`);
+    return;
+  }
+  const sorted = skills.sort((a, b) => {
+    if (a.location !== b.location) {
+      return a.location === "project" ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+  for (const skill of sorted) {
+    const locationLabel = skill.location === "project" ? chalk.blue("(project)") : chalk.dim("(global)");
+    console.log(`  ${chalk.bold(skill.name.padEnd(25))} ${locationLabel}`);
+    console.log(`    ${chalk.dim(skill.description)}
+`);
+  }
+  const projectCount = skills.filter((s) => s.location === "project").length;
+  const globalCount = skills.filter((s) => s.location === "global").length;
+  console.log(chalk.dim(`Summary: ${projectCount} project, ${globalCount} global (${skills.length} total)`));
+}
+
+// src/commands/install.ts
+import { ExitPromptError } from "@inquirer/core";
+import { checkbox, confirm } from "@inquirer/prompts";
+import chalk2 from "chalk";
+import { execSync } from "child_process";
+import { cpSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, readdirSync as readdirSync2, rmSync, statSync as statSync2 } from "fs";
+import ora from "ora";
+import { homedir as homedir2 } from "os";
+import { basename, join as join3, resolve, sep } from "path";
+
+// src/utils/marketplace-skills.ts
+var ANTHROPIC_MARKETPLACE_SKILLS = [
+  // document-skills plugin
+  "xlsx",
+  "docx",
+  "pptx",
+  "pdf",
+  // example-skills plugin
+  "algorithmic-art",
+  "artifacts-builder",
+  "brand-guidelines",
+  "canvas-design",
+  "internal-comms",
+  "mcp-builder",
+  "skill-creator",
+  "slack-gif-creator",
+  "template-skill",
+  "theme-factory",
+  "webapp-testing"
+];
+
+// src/commands/install.ts
+function isLocalPath(source) {
+  return source.startsWith("/") || source.startsWith("./") || source.startsWith("../") || source.startsWith("~/") || /^[a-zA-Z]:[\\/]/.test(source);
+}
+function isGitUrl(source) {
+  return source.startsWith("git@") || source.startsWith("git://") || source.startsWith("http://") || source.startsWith("https://") || source.endsWith(".git");
+}
+function expandPath(source) {
+  if (source.startsWith("~/")) {
+    return join3(homedir2(), source.slice(2));
+  }
+  return resolve(source);
+}
+async function installSkill(source, options) {
+  const folder = options.universal ? ".agent/skills" : ".claude/skills";
+  const isProject = !options.global;
+  const targetDir = isProject ? join3(process.cwd(), folder) : join3(homedir2(), folder);
+  const location = isProject ? chalk2.blue(`project (${folder})`) : chalk2.dim(`global (~/${folder})`);
+  console.log(`Installing from: ${chalk2.cyan(source)}`);
+  console.log(`Location: ${location}
+`);
+  if (isLocalPath(source)) {
+    const localPath = expandPath(source);
+    await installFromLocal(localPath, targetDir, options);
+    printPostInstallHints(isProject);
+    return;
+  }
+  let repoUrl;
+  let skillSubpath = "";
+  if (isGitUrl(source)) {
+    repoUrl = source;
+  } else {
+    const parts = source.split("/");
+    if (parts.length === 2) {
+      repoUrl = `https://github.com/${source}`;
+    } else if (parts.length > 2) {
+      repoUrl = `https://github.com/${parts[0]}/${parts[1]}`;
+      skillSubpath = parts.slice(2).join("/");
+    } else {
+      console.error(chalk2.red("Error: Invalid source format"));
+      console.error("Expected: owner/repo, owner/repo/skill-name, git URL, or local path");
+      process.exit(1);
+    }
+  }
+  const tempDir = join3(homedir2(), `.openskills-temp-${Date.now()}`);
+  mkdirSync(tempDir, { recursive: true });
+  try {
+    const spinner = ora("Cloning repository...").start();
+    try {
+      execSync(`git clone --depth 1 --quiet "${repoUrl}" "${tempDir}/repo"`, {
+        stdio: "pipe"
+      });
+      spinner.succeed("Repository cloned");
+    } catch (error) {
+      spinner.fail("Failed to clone repository");
+      const err = error;
+      if (err.stderr) {
+        console.error(chalk2.dim(err.stderr.toString().trim()));
+      }
+      console.error(chalk2.yellow("\nTip: For private repos, ensure git SSH keys or credentials are configured"));
+      process.exit(1);
+    }
+    const repoDir = join3(tempDir, "repo");
+    if (skillSubpath) {
+      await installSpecificSkill(repoDir, skillSubpath, targetDir, isProject, options);
+    } else {
+      await installFromRepo(repoDir, targetDir, options);
+    }
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+  printPostInstallHints(isProject);
+}
+function printPostInstallHints(isProject) {
+  console.log(`
+${chalk2.dim("Read skill:")} ${chalk2.cyan("openskills read <skill-name>")}`);
+  if (isProject) {
+    console.log(`${chalk2.dim("Sync to AGENTS.md:")} ${chalk2.cyan("openskills sync")}`);
+  }
+}
+async function installFromLocal(localPath, targetDir, options) {
+  if (!existsSync2(localPath)) {
+    console.error(chalk2.red(`Error: Path does not exist: ${localPath}`));
+    process.exit(1);
+  }
+  const stats = statSync2(localPath);
+  if (!stats.isDirectory()) {
+    console.error(chalk2.red("Error: Path must be a directory"));
+    process.exit(1);
+  }
+  const skillMdPath = join3(localPath, "SKILL.md");
+  if (existsSync2(skillMdPath)) {
+    const isProject = targetDir.includes(process.cwd());
+    await installSingleLocalSkill(localPath, targetDir, isProject, options);
+  } else {
+    await installFromRepo(localPath, targetDir, options);
+  }
+}
+async function installSingleLocalSkill(skillDir, targetDir, isProject, options) {
+  const skillMdPath = join3(skillDir, "SKILL.md");
+  const content = readFileSync2(skillMdPath, "utf-8");
+  if (!hasValidFrontmatter(content)) {
+    console.error(chalk2.red("Error: Invalid SKILL.md (missing YAML frontmatter)"));
+    process.exit(1);
+  }
+  const skillName = basename(skillDir);
+  const targetPath = join3(targetDir, skillName);
+  const shouldInstall = await warnIfConflict(skillName, targetPath, isProject, options.yes);
+  if (!shouldInstall) {
+    console.log(chalk2.yellow(`Skipped: ${skillName}`));
+    return;
+  }
+  mkdirSync(targetDir, { recursive: true });
+  const resolvedTargetPath = resolve(targetPath);
+  const resolvedTargetDir = resolve(targetDir);
+  if (!resolvedTargetPath.startsWith(resolvedTargetDir + sep)) {
+    console.error(chalk2.red(`Security error: Installation path outside target directory`));
+    process.exit(1);
+  }
+  cpSync(skillDir, targetPath, { recursive: true, dereference: true });
+  console.log(chalk2.green(`\u2705 Installed: ${skillName}`));
+  console.log(`   Location: ${targetPath}`);
+}
+async function installSpecificSkill(repoDir, skillSubpath, targetDir, isProject, options) {
+  const skillDir = join3(repoDir, skillSubpath);
+  const skillMdPath = join3(skillDir, "SKILL.md");
+  if (!existsSync2(skillMdPath)) {
+    console.error(chalk2.red(`Error: SKILL.md not found at ${skillSubpath}`));
+    process.exit(1);
+  }
+  const content = readFileSync2(skillMdPath, "utf-8");
+  if (!hasValidFrontmatter(content)) {
+    console.error(chalk2.red("Error: Invalid SKILL.md (missing YAML frontmatter)"));
+    process.exit(1);
+  }
+  const skillName = basename(skillSubpath);
+  const targetPath = join3(targetDir, skillName);
+  const shouldInstall = await warnIfConflict(skillName, targetPath, isProject, options.yes);
+  if (!shouldInstall) {
+    console.log(chalk2.yellow(`Skipped: ${skillName}`));
+    return;
+  }
+  mkdirSync(targetDir, { recursive: true });
+  const resolvedTargetPath = resolve(targetPath);
+  const resolvedTargetDir = resolve(targetDir);
+  if (!resolvedTargetPath.startsWith(resolvedTargetDir + sep)) {
+    console.error(chalk2.red(`Security error: Installation path outside target directory`));
+    process.exit(1);
+  }
+  cpSync(skillDir, targetPath, { recursive: true, dereference: true });
+  console.log(chalk2.green(`\u2705 Installed: ${skillName}`));
+  console.log(`   Location: ${targetPath}`);
+}
+async function installFromRepo(repoDir, targetDir, options) {
+  const findSkills = (dir) => {
+    const skills = [];
+    const entries = readdirSync2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (existsSync2(join3(fullPath, "SKILL.md"))) {
+          skills.push(fullPath);
+        } else {
+          skills.push(...findSkills(fullPath));
+        }
+      }
+    }
+    return skills;
+  };
+  const skillDirs = findSkills(repoDir);
+  if (skillDirs.length === 0) {
+    console.error(chalk2.red("Error: No SKILL.md files found in repository"));
+    process.exit(1);
+  }
+  console.log(chalk2.dim(`Found ${skillDirs.length} skill(s)
+`));
+  const skillInfos = skillDirs.map((skillDir) => {
+    const skillMdPath = join3(skillDir, "SKILL.md");
+    const content = readFileSync2(skillMdPath, "utf-8");
+    if (!hasValidFrontmatter(content)) {
+      return null;
+    }
+    const skillName = basename(skillDir);
+    const description = extractYamlField(content, "description");
+    const targetPath = join3(targetDir, skillName);
+    const size = getDirectorySize(skillDir);
+    return {
+      skillDir,
+      skillName,
+      description,
+      targetPath,
+      size
+    };
+  }).filter((info) => info !== null);
+  if (skillInfos.length === 0) {
+    console.error(chalk2.red("Error: No valid SKILL.md files found"));
+    process.exit(1);
+  }
+  let skillsToInstall = skillInfos;
+  if (!options.yes && skillInfos.length > 1) {
+    try {
+      const choices = skillInfos.map((info) => ({
+        name: `${chalk2.bold(info.skillName.padEnd(25))} ${chalk2.dim(formatSize(info.size))}`,
+        value: info.skillName,
+        description: info.description.slice(0, 80),
+        checked: true
+        // Check all by default
+      }));
+      const selected = await checkbox({
+        message: "Select skills to install",
+        choices,
+        pageSize: 15
+      });
+      if (selected.length === 0) {
+        console.log(chalk2.yellow("No skills selected. Installation cancelled."));
+        return;
+      }
+      skillsToInstall = skillInfos.filter((info) => selected.includes(info.skillName));
+    } catch (error) {
+      if (error instanceof ExitPromptError) {
+        console.log(chalk2.yellow("\n\nCancelled by user"));
+        process.exit(0);
+      }
+      throw error;
+    }
+  }
+  const isProject = targetDir === join3(process.cwd(), ".claude/skills");
+  let installedCount = 0;
+  for (const info of skillsToInstall) {
+    const shouldInstall = await warnIfConflict(info.skillName, info.targetPath, isProject, options.yes);
+    if (!shouldInstall) {
+      console.log(chalk2.yellow(`Skipped: ${info.skillName}`));
+      continue;
+    }
+    mkdirSync(targetDir, { recursive: true });
+    const resolvedTargetPath = resolve(info.targetPath);
+    const resolvedTargetDir = resolve(targetDir);
+    if (!resolvedTargetPath.startsWith(resolvedTargetDir + sep)) {
+      console.error(chalk2.red(`Security error: Installation path outside target directory`));
+      continue;
+    }
+    cpSync(info.skillDir, info.targetPath, { recursive: true, dereference: true });
+    console.log(chalk2.green(`\u2705 Installed: ${info.skillName}`));
+    installedCount++;
+  }
+  console.log(chalk2.green(`
+\u2705 Installation complete: ${installedCount} skill(s) installed`));
+}
+async function warnIfConflict(skillName, targetPath, isProject, skipPrompt = false) {
+  if (existsSync2(targetPath)) {
+    if (skipPrompt) {
+      console.log(chalk2.dim(`Overwriting: ${skillName}`));
+      return true;
+    }
+    try {
+      const shouldOverwrite = await confirm({
+        message: chalk2.yellow(`Skill '${skillName}' already exists. Overwrite?`),
+        default: false
+      });
+      if (!shouldOverwrite) {
+        return false;
+      }
+    } catch (error) {
+      if (error instanceof ExitPromptError) {
+        console.log(chalk2.yellow("\n\nCancelled by user"));
+        process.exit(0);
+      }
+      throw error;
+    }
+  }
+  if (!isProject && ANTHROPIC_MARKETPLACE_SKILLS.includes(skillName)) {
+    console.warn(chalk2.yellow(`
+\u26A0\uFE0F  Warning: '${skillName}' matches an Anthropic marketplace skill`));
+    console.warn(chalk2.dim("   Installing globally may conflict with Claude Code plugins."));
+    console.warn(chalk2.dim("   If you re-enable Claude plugins, this will be overwritten."));
+    console.warn(chalk2.dim("   Recommend: Use --project flag for conflict-free installation.\n"));
+  }
+  return true;
+}
+function getDirectorySize(dirPath) {
+  let size = 0;
+  const entries = readdirSync2(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join3(dirPath, entry.name);
+    if (entry.isFile()) {
+      size += statSync2(fullPath).size;
+    } else if (entry.isDirectory()) {
+      size += getDirectorySize(fullPath);
+    }
+  }
+  return size;
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+// src/commands/read.ts
+import { readFileSync as readFileSync3 } from "fs";
+function readSkill(skillName) {
+  const skill = findSkill(skillName);
+  if (!skill) {
+    console.error(`Error: Skill '${skillName}' not found`);
+    console.error("\nSearched:");
+    console.error("  .agent/skills/ (project universal)");
+    console.error("  ~/.agent/skills/ (global universal)");
+    console.error("  .claude/skills/ (project)");
+    console.error("  ~/.claude/skills/ (global)");
+    console.error("\nInstall skills: openskills install owner/repo");
+    process.exit(1);
+  }
+  const content = readFileSync3(skill.path, "utf-8");
+  console.log(`Reading: ${skillName}`);
+  console.log(`Base directory: ${skill.baseDir}`);
+  console.log("");
+  console.log(content);
+  console.log("");
+  console.log(`Skill read: ${skillName}`);
+}
+
+// src/commands/remove.ts
+import { rmSync as rmSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+function removeSkill(skillName) {
+  const skill = findSkill(skillName);
+  if (!skill) {
+    console.error(`Error: Skill '${skillName}' not found`);
+    process.exit(1);
+  }
+  rmSync2(skill.baseDir, { recursive: true, force: true });
+  const location = skill.source.includes(homedir3()) ? "global" : "project";
+  console.log(`\u2705 Removed: ${skillName}`);
+  console.log(`   From: ${location} (${skill.source})`);
+}
+
+// src/commands/manage.ts
+import { rmSync as rmSync3 } from "fs";
+import chalk3 from "chalk";
+import { checkbox as checkbox2 } from "@inquirer/prompts";
+import { ExitPromptError as ExitPromptError2 } from "@inquirer/core";
+async function manageSkills() {
+  const skills = findAllSkills();
+  if (skills.length === 0) {
+    console.log("No skills installed.");
+    return;
+  }
+  try {
+    const sorted = skills.sort((a, b) => {
+      if (a.location !== b.location) {
+        return a.location === "project" ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+    const choices = sorted.map((skill) => ({
+      name: `${chalk3.bold(skill.name.padEnd(25))} ${skill.location === "project" ? chalk3.blue("(project)") : chalk3.dim("(global)")}`,
+      value: skill.name,
+      checked: false
+      // Nothing checked by default
+    }));
+    const toRemove = await checkbox2({
+      message: "Select skills to remove",
+      choices,
+      pageSize: 15
+    });
+    if (toRemove.length === 0) {
+      console.log(chalk3.yellow("No skills selected for removal."));
+      return;
+    }
+    for (const skillName of toRemove) {
+      const skill = findSkill(skillName);
+      if (skill) {
+        rmSync3(skill.baseDir, { recursive: true, force: true });
+        const location = skill.source.includes(process.cwd()) ? "project" : "global";
+        console.log(chalk3.green(`\u2705 Removed: ${skillName} (${location})`));
+      }
+    }
+    console.log(chalk3.green(`
+\u2705 Removed ${toRemove.length} skill(s)`));
+  } catch (error) {
+    if (error instanceof ExitPromptError2) {
+      console.log(chalk3.yellow("\n\nCancelled by user"));
+      process.exit(0);
+    }
+    throw error;
+  }
+}
+
+// src/commands/sync.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { dirname, basename as basename2 } from "path";
+import chalk4 from "chalk";
+import { checkbox as checkbox3 } from "@inquirer/prompts";
+import { ExitPromptError as ExitPromptError3 } from "@inquirer/core";
+
+// src/utils/agents-md.ts
+function parseCurrentSkills(content) {
+  const skillNames = [];
+  const skillRegex = /<skill>[\s\S]*?<name>([^<]+)<\/name>[\s\S]*?<\/skill>/g;
+  let match;
+  while ((match = skillRegex.exec(content)) !== null) {
+    skillNames.push(match[1].trim());
+  }
+  return skillNames;
+}
+function generateSkillsXml(skills) {
+  const skillTags = skills.map(
+    (s) => `<skill>
+<name>${s.name}</name>
+<description>${s.description}</description>
+<location>${s.location}</location>
+</skill>`
+  ).join("\n\n");
+  return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: Bash("openskills read <skill-name>")
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillTags}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+}
+function replaceSkillsSection(content, newSection) {
+  const startMarker = "<skills_system";
+  const endMarker = "</skills_system>";
+  if (content.includes(startMarker)) {
+    const regex = /<skills_system[^>]*>[\s\S]*?<\/skills_system>/;
+    return content.replace(regex, newSection);
+  }
+  const htmlStartMarker = "<!-- SKILLS_TABLE_START -->";
+  const htmlEndMarker = "<!-- SKILLS_TABLE_END -->";
+  if (content.includes(htmlStartMarker)) {
+    const innerContent = newSection.replace(/<skills_system[^>]*>|<\/skills_system>/g, "");
+    const regex = new RegExp(
+      `${htmlStartMarker}[\\s\\S]*?${htmlEndMarker}`,
+      "g"
+    );
+    return content.replace(regex, `${htmlStartMarker}
+${innerContent}
+${htmlEndMarker}`);
+  }
+  return content.trimEnd() + "\n\n" + newSection + "\n";
+}
+function removeSkillsSection(content) {
+  const startMarker = "<skills_system";
+  const endMarker = "</skills_system>";
+  if (content.includes(startMarker)) {
+    const regex = /<skills_system[^>]*>[\s\S]*?<\/skills_system>/;
+    return content.replace(regex, "<!-- Skills section removed -->");
+  }
+  const htmlStartMarker = "<!-- SKILLS_TABLE_START -->";
+  const htmlEndMarker = "<!-- SKILLS_TABLE_END -->";
+  if (content.includes(htmlStartMarker)) {
+    const regex = new RegExp(
+      `${htmlStartMarker}[\\s\\S]*?${htmlEndMarker}`,
+      "g"
+    );
+    return content.replace(regex, `${htmlStartMarker}
+<!-- Skills section removed -->
+${htmlEndMarker}`);
+  }
+  return content;
+}
+
+// src/commands/sync.ts
+async function syncAgentsMd(options = {}) {
+  const outputPath = options.output || "AGENTS.md";
+  const outputName = basename2(outputPath);
+  if (!outputPath.endsWith(".md")) {
+    console.error(chalk4.red("Error: Output file must be a markdown file (.md)"));
+    process.exit(1);
+  }
+  if (!existsSync3(outputPath)) {
+    const dir = dirname(outputPath);
+    if (dir && dir !== "." && !existsSync3(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync(outputPath, `# ${outputName.replace(".md", "")}
+
+`);
+    console.log(chalk4.dim(`Created ${outputPath}`));
+  }
+  let skills = findAllSkills();
+  if (skills.length === 0) {
+    console.log("No skills installed. Install skills first:");
+    console.log(`  ${chalk4.cyan("openskills install anthropics/skills --project")}`);
+    return;
+  }
+  if (!options.yes) {
+    try {
+      const content2 = readFileSync4(outputPath, "utf-8");
+      const currentSkills = parseCurrentSkills(content2);
+      const sorted = skills.sort((a, b) => {
+        if (a.location !== b.location) {
+          return a.location === "project" ? -1 : 1;
+        }
+        return a.name.localeCompare(b.name);
+      });
+      const choices = sorted.map((skill) => ({
+        name: `${chalk4.bold(skill.name.padEnd(25))} ${skill.location === "project" ? chalk4.blue("(project)") : chalk4.dim("(global)")}`,
+        value: skill.name,
+        description: skill.description.slice(0, 70),
+        // Pre-select if currently in file, otherwise default to project skills
+        checked: currentSkills.includes(skill.name) || currentSkills.length === 0 && skill.location === "project"
+      }));
+      const selected = await checkbox3({
+        message: `Select skills to sync to ${outputName}`,
+        choices,
+        pageSize: 15
+      });
+      if (selected.length === 0) {
+        const content3 = readFileSync4(outputPath, "utf-8");
+        const updated2 = removeSkillsSection(content3);
+        writeFileSync(outputPath, updated2);
+        console.log(chalk4.green(`\u2705 Removed all skills from ${outputName}`));
+        return;
+      }
+      skills = skills.filter((s) => selected.includes(s.name));
+    } catch (error) {
+      if (error instanceof ExitPromptError3) {
+        console.log(chalk4.yellow("\n\nCancelled by user"));
+        process.exit(0);
+      }
+      throw error;
+    }
+  }
+  const xml = generateSkillsXml(skills);
+  const content = readFileSync4(outputPath, "utf-8");
+  const updated = replaceSkillsSection(content, xml);
+  writeFileSync(outputPath, updated);
+  const hadMarkers = content.includes("<skills_system") || content.includes("<!-- SKILLS_TABLE_START -->");
+  if (hadMarkers) {
+    console.log(chalk4.green(`\u2705 Synced ${skills.length} skill(s) to ${outputName}`));
+  } else {
+    console.log(chalk4.green(`\u2705 Added skills section to ${outputName} (${skills.length} skill(s))`));
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("openskills").description("Universal skills loader for AI coding agents").version("1.2.1").showHelpAfterError(false).exitOverride((err) => {
+  if (err.code === "commander.helpDisplayed" || err.code === "commander.help" || err.code === "commander.version") {
+    process.exit(0);
+  }
+  if (err.code === "commander.missingArgument" || err.code === "commander.missingMandatoryOptionValue") {
+    process.exit(1);
+  }
+  if (err.code === "commander.unknownOption" || err.code === "commander.invalidArgument") {
+    process.exit(1);
+  }
+  process.exit(err.exitCode || 1);
+});
+program.command("list").description("List all installed skills").action(listSkills);
+program.command("install <source>").description("Install skill from GitHub or Git URL").option("-g, --global", "Install globally (default: project install)").option("-u, --universal", "Install to .agent/skills/ (for universal AGENTS.md usage)").option("-y, --yes", "Skip interactive selection, install all skills found").action(installSkill);
+program.command("read <skill-name>").description("Read skill to stdout (for AI agents)").action(readSkill);
+program.command("sync").description("Update AGENTS.md with installed skills (interactive, pre-selects current state)").option("-y, --yes", "Skip interactive selection, sync all skills").option("-o, --output <path>", "Output file path (default: AGENTS.md)").action(syncAgentsMd);
+program.command("manage").description("Interactively manage (remove) installed skills").action(manageSkills);
+program.command("remove <skill-name>").alias("rm").description("Remove specific skill (for scripts, use manage for interactive)").action(removeSkill);
+program.parse();