openskill-ai 1.0.0

package/dist/cli.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+import {
+  agents,
+  cleanupTempDir,
+  cloneRepo,
+  detectInstalledAgents,
+  discoverSkills,
+  getInstallPath,
+  getSkillDisplayName,
+  installSkillForAgent,
+  isSkillInstalled,
+  parseSource
+} from "./chunk-63EFN7CX.js";
+
+// src/cli.ts
+import { program } from "commander";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var packageJsonPath = join(__dirname, "../package.json");
+var packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+var version = packageJson.version;
+program.name("agent-skills").description("Install skills onto AI coding agents from git repositories").version(version).argument("<source>", "Git repo URL, GitHub shorthand (owner/repo), or direct path to skill").option("-g, --global", "Install skill globally (user-level) instead of project-level").option("-a, --agent <agents...>", "Specify agents to install to (use --list-agents to see available agents)").option("-s, --skill <skills...>", "Specify skill names to install (skip selection prompt)").option("-l, --list", "List available skills in the repository without installing").option("-y, --yes", "Skip confirmation prompts").configureOutput({
+  outputError: (str, write) => {
+    if (str.includes("missing required argument")) {
+      console.log();
+      console.log(chalk.bgRed.white.bold(" ERROR ") + " " + chalk.red("Missing required argument: source"));
+      console.log();
+      console.log(chalk.dim("  Usage:"));
+      console.log(`    ${chalk.cyan("npx agent-skills")} ${chalk.yellow("<source>")} ${chalk.dim("[options]")}`);
+      console.log();
+      console.log(chalk.dim("  Example:"));
+      console.log(`    ${chalk.cyan("npx agent-skills")} ${chalk.yellow("vercel-labs/agent-skills")}`);
+      console.log();
+      console.log(chalk.dim("  Run") + ` ${chalk.cyan("npx agent-skills --help")} ` + chalk.dim("for more information."));
+      console.log();
+    } else {
+      write(str);
+    }
+  }
+}).action(async (source, options) => {
+  await main(source, options);
+});
+program.command("list-agents").description("List all supported AI coding agents").action(() => {
+  console.log();
+  console.log(chalk.bold("Supported AI Coding Agents:"));
+  console.log();
+  Object.entries(agents).forEach(([id, config]) => {
+    console.log(`  ${chalk.cyan(id.padEnd(18))} ${chalk.dim(config.displayName)}`);
+    console.log(`    ${chalk.gray(`Project: ${config.skillsDir}`)}`);
+    console.log(`    ${chalk.gray(`Global:  ${config.globalSkillsDir}`)}`);
+  });
+  console.log();
+});
+program.parse();
+async function main(source, options) {
+  console.log();
+  p.intro(chalk.bgCyan.black(" agent-skills "));
+  let tempDir = null;
+  try {
+    const spinner2 = p.spinner();
+    spinner2.start("Parsing source...");
+    const parsed = parseSource(source);
+    spinner2.stop(`Source: ${chalk.cyan(parsed.url)}${parsed.subpath ? ` (${parsed.subpath})` : ""}`);
+    spinner2.start("Cloning repository...");
+    tempDir = await cloneRepo(parsed.url);
+    spinner2.stop("Repository cloned");
+    spinner2.start("Discovering skills...");
+    const skills = await discoverSkills(tempDir, parsed.subpath);
+    if (skills.length === 0) {
+      spinner2.stop(chalk.red("No skills found"));
+      p.outro(chalk.red("No valid skills found. Skills require a SKILL.md with name and description."));
+      await cleanup(tempDir);
+      process.exit(1);
+    }
+    spinner2.stop(`Found ${chalk.green(skills.length)} skill${skills.length > 1 ? "s" : ""}`);
+    if (options.list) {
+      console.log();
+      p.log.step(chalk.bold("Available Skills"));
+      for (const skill of skills) {
+        p.log.message(`  ${chalk.cyan(getSkillDisplayName(skill))}`);
+        p.log.message(`    ${chalk.dim(skill.description)}`);
+      }
+      console.log();
+      p.outro("Use --skill <name> to install specific skills");
+      await cleanup(tempDir);
+      process.exit(0);
+    }
+    let selectedSkills;
+    if (options.skill && options.skill.length > 0) {
+      selectedSkills = skills.filter(
+        (s) => options.skill.some(
+          (name) => s.name.toLowerCase() === name.toLowerCase() || getSkillDisplayName(s).toLowerCase() === name.toLowerCase()
+        )
+      );
+      if (selectedSkills.length === 0) {
+        p.log.error(`No matching skills found for: ${options.skill.join(", ")}`);
+        p.log.info("Available skills:");
+        for (const s of skills) {
+          p.log.message(`  - ${getSkillDisplayName(s)}`);
+        }
+        await cleanup(tempDir);
+        process.exit(1);
+      }
+      p.log.info(`Selected ${selectedSkills.length} skill${selectedSkills.length !== 1 ? "s" : ""}: ${selectedSkills.map((s) => chalk.cyan(getSkillDisplayName(s))).join(", ")}`);
+    } else if (skills.length === 1) {
+      selectedSkills = skills;
+      const firstSkill = skills[0];
+      p.log.info(`Skill: ${chalk.cyan(getSkillDisplayName(firstSkill))}`);
+      p.log.message(chalk.dim(firstSkill.description));
+    } else if (options.yes) {
+      selectedSkills = skills;
+      p.log.info(`Installing all ${skills.length} skills`);
+    } else {
+      const skillChoices = skills.map((s) => ({
+        value: s,
+        label: getSkillDisplayName(s),
+        hint: s.description.length > 60 ? s.description.slice(0, 57) + "..." : s.description
+      }));
+      const selected = await p.multiselect({
+        message: "Select skills to install",
+        options: skillChoices,
+        required: true
+      });
+      if (p.isCancel(selected)) {
+        p.cancel("Installation cancelled");
+        await cleanup(tempDir);
+        process.exit(0);
+      }
+      selectedSkills = selected;
+    }
+    let targetAgents;
+    const validAgents = Object.keys(agents);
+    if (options.agent && options.agent.length > 0) {
+      const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+      if (invalidAgents.length > 0) {
+        p.log.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+        p.log.info(`Valid agents: ${validAgents.join(", ")}`);
+        p.log.info(`Run 'agent-skills list-agents' to see all supported agents`);
+        await cleanup(tempDir);
+        process.exit(1);
+      }
+      targetAgents = options.agent;
+    } else {
+      spinner2.start("Detecting installed agents...");
+      const installedAgents = await detectInstalledAgents();
+      spinner2.stop(`Detected ${installedAgents.length} agent${installedAgents.length !== 1 ? "s" : ""}`);
+      if (installedAgents.length === 0) {
+        if (options.yes) {
+          targetAgents = validAgents;
+          p.log.info("Installing to all agents (none detected)");
+        } else {
+          p.log.warn("No coding agents detected. You can still install skills.");
+          const allAgentChoices = Object.entries(agents).map(([key, config]) => ({
+            value: key,
+            label: config.displayName
+          }));
+          const selected = await p.multiselect({
+            message: "Select agents to install skills to",
+            options: allAgentChoices,
+            required: true
+          });
+          if (p.isCancel(selected)) {
+            p.cancel("Installation cancelled");
+            await cleanup(tempDir);
+            process.exit(0);
+          }
+          targetAgents = selected;
+        }
+      } else if (installedAgents.length === 1 || options.yes) {
+        targetAgents = installedAgents;
+        if (installedAgents.length === 1) {
+          const firstAgent = installedAgents[0];
+          p.log.info(`Installing to: ${chalk.cyan(agents[firstAgent].displayName)}`);
+        } else {
+          p.log.info(`Installing to: ${installedAgents.map((a) => chalk.cyan(agents[a].displayName)).join(", ")}`);
+        }
+      } else {
+        const agentChoices = installedAgents.map((a) => ({
+          value: a,
+          label: agents[a].displayName,
+          hint: `${options.global ? agents[a].globalSkillsDir : agents[a].skillsDir}`
+        }));
+        const selected = await p.multiselect({
+          message: "Select agents to install skills to",
+          options: agentChoices,
+          required: true,
+          initialValues: installedAgents
+        });
+        if (p.isCancel(selected)) {
+          p.cancel("Installation cancelled");
+          await cleanup(tempDir);
+          process.exit(0);
+        }
+        targetAgents = selected;
+      }
+    }
+    let installGlobally = options.global ?? false;
+    if (options.global === void 0 && !options.yes) {
+      const scope = await p.select({
+        message: "Installation scope",
+        options: [
+          { value: false, label: "Project", hint: "Install in current directory (committed with your project)" },
+          { value: true, label: "Global", hint: "Install in home directory (available across all projects)" }
+        ]
+      });
+      if (p.isCancel(scope)) {
+        p.cancel("Installation cancelled");
+        await cleanup(tempDir);
+        process.exit(0);
+      }
+      installGlobally = scope;
+    }
+    console.log();
+    p.log.step(chalk.bold("Installation Summary"));
+    for (const skill of selectedSkills) {
+      p.log.message(`  ${chalk.cyan(getSkillDisplayName(skill))}`);
+      for (const agent of targetAgents) {
+        const path = getInstallPath(skill.name, agent, { global: installGlobally });
+        const installed = await isSkillInstalled(skill.name, agent, { global: installGlobally });
+        const status = installed ? chalk.yellow(" (will overwrite)") : "";
+        p.log.message(`    ${chalk.dim("\u2192")} ${agents[agent].displayName}: ${chalk.dim(path)}${status}`);
+      }
+    }
+    console.log();
+    if (!options.yes) {
+      const confirmed = await p.confirm({ message: "Proceed with installation?" });
+      if (p.isCancel(confirmed) || !confirmed) {
+        p.cancel("Installation cancelled");
+        await cleanup(tempDir);
+        process.exit(0);
+      }
+    }
+    spinner2.start("Installing skills...");
+    const results = [];
+    for (const skill of selectedSkills) {
+      for (const agent of targetAgents) {
+        const result = await installSkillForAgent(skill, agent, { global: installGlobally });
+        results.push({
+          skill: getSkillDisplayName(skill),
+          agent: agents[agent].displayName,
+          ...result
+        });
+      }
+    }
+    spinner2.stop("Installation complete");
+    console.log();
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    if (successful.length > 0) {
+      p.log.success(chalk.green(`Successfully installed ${successful.length} skill${successful.length !== 1 ? "s" : ""}`));
+      for (const r of successful) {
+        p.log.message(`  ${chalk.green("\u2713")} ${r.skill} \u2192 ${r.agent}`);
+        p.log.message(`    ${chalk.dim(r.path)}`);
+      }
+    }
+    if (failed.length > 0) {
+      console.log();
+      p.log.error(chalk.red(`Failed to install ${failed.length} skill${failed.length !== 1 ? "s" : ""}`));
+      for (const r of failed) {
+        p.log.message(`  ${chalk.red("\u2717")} ${r.skill} \u2192 ${r.agent}`);
+        p.log.message(`    ${chalk.dim(r.error)}`);
+      }
+    }
+    console.log();
+    p.outro(chalk.green("Done!"));
+  } catch (error) {
+    p.log.error(error instanceof Error ? error.message : "Unknown error occurred");
+    p.outro(chalk.red("Installation failed"));
+    process.exit(1);
+  } finally {
+    await cleanup(tempDir);
+  }
+}
+async function cleanup(tempDir) {
+  if (tempDir) {
+    try {
+      await cleanupTempDir(tempDir);
+    } catch {
+    }
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,158 @@
+interface InstallOptions {
+    dir?: string;
+}
+/**
+ * Install one or more skills
+ */
+declare function installSkills(skillIds: string[], options: InstallOptions): Promise<void>;
+
+interface ListOptions {
+    dir?: string;
+}
+/**
+ * List available and installed skills
+ */
+declare function listSkills(options: ListOptions): Promise<void>;
+
+interface RemoveOptions {
+    dir?: string;
+}
+/**
+ * Remove one or more skills
+ */
+declare function removeSkills(skillIds: string[], options: RemoveOptions): Promise<void>;
+
+interface InitOptions {
+    dir?: string;
+}
+/**
+ * Initialize .agents folder
+ */
+declare function initAgents(options: InitOptions): Promise<void>;
+
+/**
+ * Skill Registry
+ * Defines all available skills and their metadata
+ */
+interface SkillInfo {
+    folderName: string;
+    description: string;
+    tags: string[];
+}
+interface SkillRegistry {
+    [key: string]: SkillInfo;
+}
+interface SkillWithId extends SkillInfo {
+    id: string;
+}
+/**
+ * Get skill info by ID
+ */
+declare function getSkill(skillId: string): SkillInfo | null;
+/**
+ * Get all skills with full info
+ */
+declare function getAllSkills(): SkillWithId[];
+/**
+ * Check if skill exists
+ */
+declare function skillExists(skillId: string): boolean;
+
+/**
+ * Type definitions for agent-skills package
+ */
+type AgentType = 'opencode' | 'claude-code' | 'codex' | 'cursor' | 'amp' | 'kilo' | 'roo' | 'goose' | 'antigravity' | 'gemini-cli' | 'github-copilot' | 'clawdbot' | 'droid' | 'gemini' | 'windsurf';
+interface Skill {
+    name: string;
+    description: string;
+    path: string;
+    metadata?: Record<string, string>;
+}
+interface AgentConfig {
+    name: string;
+    displayName: string;
+    skillsDir: string;
+    globalSkillsDir: string;
+    detectInstalled: () => Promise<boolean>;
+}
+interface ParsedSource {
+    type: 'github' | 'gitlab' | 'git';
+    url: string;
+    subpath?: string;
+}
+
+/**
+ * Parse various Git source formats into a normalized structure
+ * Supports:
+ * - GitHub URLs with paths: https://github.com/owner/repo/tree/branch/path/to/skill
+ * - GitHub URLs: https://github.com/owner/repo
+ * - GitLab URLs with paths: https://gitlab.com/owner/repo/-/tree/branch/path
+ * - GitLab URLs: https://gitlab.com/owner/repo
+ * - GitHub shorthand: owner/repo or owner/repo/path/to/skill
+ * - Direct git URLs: git@github.com:owner/repo.git
+ */
+declare function parseSource(input: string): ParsedSource;
+/**
+ * Clone a Git repository to a temporary directory
+ * Uses shallow clone (depth 1) for faster downloads
+ */
+declare function cloneRepo(url: string): Promise<string>;
+/**
+ * Safely cleanup a temporary directory
+ * Validates that the directory is within tmpdir to prevent accidental deletion
+ */
+declare function cleanupTempDir(dir: string): Promise<void>;
+
+/**
+ * Discover all skills in a directory
+ * Searches priority locations first, then falls back to recursive search
+ */
+declare function discoverSkills(basePath: string, subpath?: string): Promise<Skill[]>;
+/**
+ * Get the display name for a skill
+ */
+declare function getSkillDisplayName(skill: Skill): string;
+
+/**
+ * Configuration for all supported AI coding agents
+ * Includes installation detection and directory paths for each agent
+ */
+declare const agents: Record<AgentType, AgentConfig>;
+/**
+ * Detect all installed AI coding agents on the system
+ */
+declare function detectInstalledAgents(): Promise<AgentType[]>;
+/**
+ * Get configuration for a specific agent
+ */
+declare function getAgentConfig(type: AgentType): AgentConfig;
+
+interface InstallResult {
+    success: boolean;
+    path: string;
+    error?: string;
+}
+/**
+ * Install a skill to a specific agent
+ * Supports both global and project-level installation
+ */
+declare function installSkillForAgent(skill: Skill, agentType: AgentType, options?: {
+    global?: boolean;
+    cwd?: string;
+}): Promise<InstallResult>;
+/**
+ * Check if a skill is already installed
+ */
+declare function isSkillInstalled(skillName: string, agentType: AgentType, options?: {
+    global?: boolean;
+    cwd?: string;
+}): Promise<boolean>;
+/**
+ * Get the installation path for a skill
+ */
+declare function getInstallPath(skillName: string, agentType: AgentType, options?: {
+    global?: boolean;
+    cwd?: string;
+}): string;
+
+export { type AgentConfig, type AgentType, type InitOptions, type InstallOptions, type ListOptions, type ParsedSource, type RemoveOptions, type Skill, type SkillInfo, type SkillRegistry, type SkillWithId, agents, cleanupTempDir, cloneRepo, detectInstalledAgents, discoverSkills, getAgentConfig, getAllSkills, getInstallPath, getSkill, getSkillDisplayName, initAgents, installSkillForAgent, installSkills, isSkillInstalled, listSkills, parseSource, removeSkills, skillExists };