@tomaskral/skillmanager 0.1.0

package/README.md

@@ -0,0 +1,106 @@
+# skillmanager
+
+A CLI tool for installing and updating [Claude Code](https://docs.anthropic.com/en/docs/claude-code) skills from local paths or GitHub URLs.
+
+## Why
+
+The `~/.claude/skills/` directory is becoming a standard path for AI coding assistants to discover reusable skills. Claude Code uses it natively, and other tools like Cursor are adopting the same convention. However, there is no built-in way to install skills into this directory from external sources, and more importantly, no way to keep them up to date as upstream skill repositories evolve.
+
+skillmanager fills that gap. It handles installation from local paths or GitHub URLs, tracks provenance via metadata, and provides an update mechanism that detects upstream changes by comparing git commit SHAs.
+
+## How it works
+
+Skills are installed into `~/.claude/skills/` where Claude Code can discover and use them.
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/) >= 18
+
+## Installation
+
+```bash
+npm install -g skillmanager
+```
+
+## Usage
+
+### Install a skill
+
+From a local path:
+
+```bash
+npx skillmanager install ~/Code/my-plugins/skills/my-skill
+npx skillmanager install ./plugins/jira-utils/skills/use-jira-cli
+```
+
+From a GitHub URL (use the `tree` URL for the skill directory):
+
+```bash
+npx skillmanager install https://github.com/owner/repo/tree/main/path/to/skill
+```
+
+If the skill already exists, use `--force` to overwrite:
+
+```bash
+npx skillmanager install ./path/to/skill --force
+```
+
+Preview what would happen without making changes:
+
+```bash
+npx skillmanager install ./path/to/skill --dry-run
+```
+
+### Update installed skills
+
+Update a single skill:
+
+```bash
+npx skillmanager update my-skill
+```
+
+Update all installed skills:
+
+```bash
+npx skillmanager update --all
+```
+
+Force re-install even if already up to date:
+
+```bash
+npx skillmanager update my-skill --force
+```
+
+## Details
+
+1. **Install** copies a skill directory into `~/.claude/skills/<skill-name>/`. The source directory must contain a `SKILL.md` file. A `.metadata.json` file is written alongside the skill to track where it came from and what commit it was installed from.
+
+2. **Update** reads `.metadata.json` from installed skills and compares the stored git commit against the current commit at the source (local git HEAD or GitHub API). If a newer commit is found, the skill is re-copied.
+
+### GitHub installs
+
+GitHub sources are specified as `https://github.com/owner/repo/tree/branch/path/to/skill`. The tool downloads the branch tarball and extracts only the target subdirectory.
+
+Set the `GITHUB_TOKEN` environment variable to authenticate API requests and avoid rate limits:
+
+```bash
+export GITHUB_TOKEN=ghp_...
+```
+
+### Metadata tracking
+
+Each installed skill gets a `.metadata.json` file containing:
+
+- **Source type** — `github` or `local`
+- **Source location** — URL or filesystem path
+- **Git commit SHA** — used for change detection during updates
+- **Timestamps** — `installed_at` and `updated_at`
+
+## Options reference
+
+| Flag | Description |
+|------|-------------|
+| `--force` | Overwrite an existing skill or force re-install even if up to date |
+| `--dry-run` | Show what would happen without making changes |
+| `--all` | Update all installed skills (update command only) |
+| `--help` | Show help message |

package/dist/commands/install.d.ts

@@ -0,0 +1,7 @@
+interface InstallOptions {
+    source: string;
+    force: boolean;
+    dryRun: boolean;
+}
+export declare function install(options: InstallOptions): Promise<void>;
+export {};

package/dist/commands/install.js

@@ -0,0 +1,129 @@
+import { existsSync, mkdirSync, rmSync, cpSync, mkdtempSync } from "fs";
+import { join, basename } from "path";
+import { tmpdir } from "os";
+import { SKILLS_DIR, validateSkillDir, log, info, error, success } from "../utils.js";
+import { writeMetadata } from "../metadata.js";
+import { parseGitHubUrl, downloadSkill, fetchLatestCommit } from "../sources/github.js";
+import { resolveLocalPath, getGitCommit } from "../sources/local.js";
+export async function install(options) {
+    const { source, force, dryRun } = options;
+    const isGitHub = source.startsWith("https://github.com/");
+    if (isGitHub) {
+        await installFromGitHub(source, force, dryRun);
+    }
+    else {
+        await installFromLocal(source, force, dryRun);
+    }
+}
+async function installFromGitHub(url, force, dryRun) {
+    const parsed = parseGitHubUrl(url);
+    const skillName = basename(parsed.path);
+    const dest = join(SKILLS_DIR, skillName);
+    info(`Fetching skill '${skillName}' from GitHub...`);
+    log(`  Repo:   ${parsed.owner}/${parsed.repo}`);
+    log(`  Branch: ${parsed.branch}`);
+    log(`  Path:   ${parsed.path}`);
+    log("");
+    if (existsSync(dest)) {
+        if (!force) {
+            error(`Skill '${skillName}' already exists at ${dest}`);
+            log("Use --force to overwrite");
+            process.exit(1);
+        }
+        if (dryRun) {
+            log(`Would replace existing skill: ${skillName}`);
+        }
+    }
+    if (dryRun) {
+        log(`Would install skill '${skillName}' to ${dest}`);
+        log("");
+        log("Dry run complete. No changes made.");
+        return;
+    }
+    // Download to a temp directory first, then move
+    const tmpDir = mkdtempSync(join(tmpdir(), "skillmanager-install-"));
+    try {
+        await downloadSkill(parsed, tmpDir);
+        validateSkillDir(tmpDir);
+        // Fetch commit SHA
+        let commitSha;
+        try {
+            commitSha = await fetchLatestCommit(parsed);
+        }
+        catch {
+            commitSha = "unknown";
+        }
+        // Ensure skills directory exists
+        if (!existsSync(SKILLS_DIR)) {
+            mkdirSync(SKILLS_DIR, { recursive: true });
+        }
+        // Remove existing if force
+        if (existsSync(dest)) {
+            rmSync(dest, { recursive: true });
+        }
+        // Copy to destination
+        cpSync(tmpDir, dest, { recursive: true });
+        // Write metadata
+        const now = new Date().toISOString();
+        const metadata = {
+            source_type: "github",
+            source_url: url,
+            github_commit: commitSha,
+            installed_at: now,
+            updated_at: now,
+        };
+        writeMetadata(dest, metadata);
+        success(`Installed skill '${skillName}' to ${dest}`);
+    }
+    finally {
+        rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+async function installFromLocal(source, force, dryRun) {
+    const resolvedPath = resolveLocalPath(source);
+    const skillName = basename(resolvedPath);
+    const dest = join(SKILLS_DIR, skillName);
+    validateSkillDir(resolvedPath);
+    info(`Installing skill '${skillName}' from local path...`);
+    log(`  Source: ${resolvedPath}`);
+    log("");
+    if (existsSync(dest)) {
+        if (!force) {
+            error(`Skill '${skillName}' already exists at ${dest}`);
+            log("Use --force to overwrite");
+            process.exit(1);
+        }
+        if (dryRun) {
+            log(`Would replace existing skill: ${skillName}`);
+        }
+    }
+    if (dryRun) {
+        log(`Would install skill '${skillName}' to ${dest}`);
+        log("");
+        log("Dry run complete. No changes made.");
+        return;
+    }
+    // Detect git commit
+    const gitCommit = await getGitCommit(resolvedPath);
+    // Ensure skills directory exists
+    if (!existsSync(SKILLS_DIR)) {
+        mkdirSync(SKILLS_DIR, { recursive: true });
+    }
+    // Remove existing if force
+    if (existsSync(dest)) {
+        rmSync(dest, { recursive: true });
+    }
+    // Copy to destination
+    cpSync(resolvedPath, dest, { recursive: true });
+    // Write metadata
+    const now = new Date().toISOString();
+    const metadata = {
+        source_type: "local",
+        source_path: resolvedPath,
+        installed_at: now,
+        updated_at: now,
+        ...(gitCommit ? { local_git_commit: gitCommit } : {}),
+    };
+    writeMetadata(dest, metadata);
+    success(`Installed skill '${skillName}' to ${dest}`);
+}

package/dist/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function list(): void;

package/dist/commands/list.js

@@ -0,0 +1,35 @@
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+import { SKILLS_DIR, log, info } from "../utils.js";
+import { readMetadata } from "../metadata.js";
+export function list() {
+    if (!existsSync(SKILLS_DIR)) {
+        log("No skills installed.");
+        return;
+    }
+    const entries = readdirSync(SKILLS_DIR, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => ({
+        name: entry.name,
+        metadata: readMetadata(join(SKILLS_DIR, entry.name)),
+    }))
+        .filter((entry) => entry.metadata !== null);
+    if (entries.length === 0) {
+        log("No skills installed.");
+        return;
+    }
+    info(`Installed skills (${entries.length}):\n`);
+    for (const { name, metadata } of entries) {
+        const source = metadata.source_type === "github"
+            ? metadata.source_url
+            : metadata.source_path;
+        const commit = metadata.source_type === "github"
+            ? metadata.github_commit.slice(0, 12)
+            : metadata.local_git_commit?.slice(0, 12) ?? "unknown";
+        log(`  ${name}`);
+        log(`    source: ${source}`);
+        log(`    commit: ${commit}`);
+        log(`    updated: ${metadata.updated_at}`);
+        log("");
+    }
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,8 @@
+interface UpdateOptions {
+    skillName?: string;
+    all: boolean;
+    force: boolean;
+    dryRun: boolean;
+}
+export declare function update(options: UpdateOptions): Promise<void>;
+export {};

package/dist/commands/update.js

@@ -0,0 +1,153 @@
+import { existsSync, readdirSync, rmSync, cpSync, mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { SKILLS_DIR, validateSkillDir, log, info, error, success } from "../utils.js";
+import { readMetadata, writeMetadata, } from "../metadata.js";
+import { parseGitHubUrl, downloadSkill, fetchLatestCommit } from "../sources/github.js";
+import { getGitCommit } from "../sources/local.js";
+export async function update(options) {
+    const { skillName, all, force, dryRun } = options;
+    if (!skillName && !all) {
+        error("Specify a skill name or use --all");
+        process.exit(1);
+    }
+    if (!existsSync(SKILLS_DIR)) {
+        error(`Skills directory not found: ${SKILLS_DIR}`);
+        process.exit(1);
+    }
+    const skillNames = all ? getInstalledSkills() : [skillName];
+    if (skillNames.length === 0) {
+        log("No installed skills with metadata found.");
+        return;
+    }
+    for (const name of skillNames) {
+        await updateSkill(name, force, dryRun);
+    }
+}
+function getInstalledSkills() {
+    if (!existsSync(SKILLS_DIR))
+        return [];
+    return readdirSync(SKILLS_DIR, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .filter((entry) => {
+        const metadata = readMetadata(join(SKILLS_DIR, entry.name));
+        return metadata !== null;
+    })
+        .map((entry) => entry.name);
+}
+async function updateSkill(skillName, force, dryRun) {
+    const skillDir = join(SKILLS_DIR, skillName);
+    if (!existsSync(skillDir)) {
+        error(`Skill '${skillName}' is not installed`);
+        return;
+    }
+    const metadata = readMetadata(skillDir);
+    if (!metadata) {
+        error(`Skill '${skillName}' has no metadata — cannot update. Reinstall it.`);
+        return;
+    }
+    info(`Checking '${skillName}' for updates...`);
+    if (metadata.source_type === "github") {
+        await updateGitHubSkill(skillName, skillDir, metadata, force, dryRun);
+    }
+    else {
+        await updateLocalSkill(skillName, skillDir, metadata, force, dryRun);
+    }
+}
+async function updateGitHubSkill(skillName, skillDir, metadata, force, dryRun) {
+    const parsed = parseGitHubUrl(metadata.source_url);
+    let latestCommit;
+    try {
+        latestCommit = await fetchLatestCommit(parsed);
+    }
+    catch (err) {
+        error(`Failed to check for updates: ${err instanceof Error ? err.message : err}`);
+        return;
+    }
+    if (latestCommit === metadata.github_commit && !force) {
+        log(`  Up to date (commit: ${latestCommit.slice(0, 12)})`);
+        return;
+    }
+    if (latestCommit === metadata.github_commit && force) {
+        log(`  Already at latest commit, but --force specified`);
+    }
+    else {
+        log(`  Update available: ${metadata.github_commit.slice(0, 12)} -> ${latestCommit.slice(0, 12)}`);
+    }
+    if (dryRun) {
+        log(`  Would update skill '${skillName}'`);
+        return;
+    }
+    const tmpDir = mkdtempSync(join(tmpdir(), "skillmanager-update-"));
+    try {
+        await downloadSkill(parsed, tmpDir);
+        validateSkillDir(tmpDir);
+        // Replace skill contents
+        rmSync(skillDir, { recursive: true });
+        cpSync(tmpDir, skillDir, { recursive: true });
+        // Update metadata
+        const now = new Date().toISOString();
+        const updatedMetadata = {
+            ...metadata,
+            github_commit: latestCommit,
+            updated_at: now,
+        };
+        writeMetadata(skillDir, updatedMetadata);
+        success(`  Updated '${skillName}'`);
+    }
+    finally {
+        rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+async function updateLocalSkill(skillName, skillDir, metadata, force, dryRun) {
+    const sourcePath = metadata.source_path;
+    if (!existsSync(sourcePath)) {
+        error(`Source path no longer exists: ${sourcePath}`);
+        return;
+    }
+    const currentCommit = await getGitCommit(sourcePath);
+    const storedCommit = metadata.local_git_commit;
+    // Determine if update is needed
+    let needsUpdate = force;
+    if (storedCommit && currentCommit) {
+        if (storedCommit !== currentCommit) {
+            log(`  Update available: ${storedCommit.slice(0, 12)} -> ${currentCommit.slice(0, 12)}`);
+            needsUpdate = true;
+        }
+        else if (!force) {
+            log(`  Up to date (commit: ${currentCommit.slice(0, 12)})`);
+            return;
+        }
+        else {
+            log(`  Already at latest commit, but --force specified`);
+        }
+    }
+    else {
+        // No git commits to compare — always update if force, otherwise note it
+        if (!force) {
+            log(`  No git commit info available. Use --force to re-copy.`);
+            return;
+        }
+        log(`  --force specified, re-copying from source`);
+        needsUpdate = true;
+    }
+    if (!needsUpdate)
+        return;
+    if (dryRun) {
+        log(`  Would update skill '${skillName}'`);
+        return;
+    }
+    validateSkillDir(sourcePath);
+    // Replace skill contents
+    rmSync(skillDir, { recursive: true });
+    cpSync(sourcePath, skillDir, { recursive: true });
+    // Update metadata
+    const now = new Date().toISOString();
+    const updatedMetadata = {
+        ...metadata,
+        updated_at: now,
+        ...(currentCommit ? { local_git_commit: currentCommit } : {}),
+    };
+    writeMetadata(skillDir, updatedMetadata);
+    success(`  Updated '${skillName}'`);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import { install } from "./commands/install.js";
+import { list } from "./commands/list.js";
+import { update } from "./commands/update.js";
+import { error, log } from "./utils.js";
+const HELP = `
+skillmanager - Install and update Claude Code skills
+
+Usage:
+  skillmanager install <local-path-or-github-url> [--force] [--dry-run]
+  skillmanager list
+  skillmanager update [<skill-name>] [--all] [--force] [--dry-run]
+
+Commands:
+  install    Install a skill from a local path or GitHub URL
+  list       List all installed skills
+  update     Check for updates and re-install changed skills
+
+Options:
+  --force    Overwrite existing skill / force re-install
+  --dry-run  Show what would be done without making changes
+  --all      Update all installed skills (update command only)
+  --help     Show this help message
+
+Examples:
+  skillmanager install ~/Code/my-plugins/skills/my-skill
+  skillmanager install https://github.com/owner/repo/tree/branch/path/to/skill
+  skillmanager install ./plugins/jira-utils/skills/use-jira-cli --force
+  skillmanager update my-skill --dry-run
+  skillmanager update --all
+`.trim();
+function parseArgs(argv) {
+    // argv[0] = bun, argv[1] = script path
+    const args = argv.slice(2);
+    if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+        log(HELP);
+        process.exit(0);
+    }
+    const subcommand = args[0];
+    const rest = args.slice(1);
+    const flags = {
+        force: false,
+        dryRun: false,
+        all: false,
+    };
+    const positional = [];
+    for (const arg of rest) {
+        switch (arg) {
+            case "--force":
+                flags.force = true;
+                break;
+            case "--dry-run":
+                flags.dryRun = true;
+                break;
+            case "--all":
+                flags.all = true;
+                break;
+            default:
+                if (arg.startsWith("-")) {
+                    error(`Unknown option: ${arg}`);
+                    process.exit(1);
+                }
+                positional.push(arg);
+                break;
+        }
+    }
+    return { subcommand, positional, flags };
+}
+async function main() {
+    const { subcommand, positional, flags } = parseArgs(process.argv);
+    switch (subcommand) {
+        case "install": {
+            if (positional.length === 0) {
+                error("Missing source argument for install");
+                log("Usage: skillmanager install <local-path-or-github-url> [--force] [--dry-run]");
+                process.exit(1);
+            }
+            if (positional.length > 1) {
+                error("Only one source argument is allowed");
+                process.exit(1);
+            }
+            await install({
+                source: positional[0],
+                force: flags.force,
+                dryRun: flags.dryRun,
+            });
+            break;
+        }
+        case "list": {
+            list();
+            break;
+        }
+        case "update": {
+            await update({
+                skillName: positional[0],
+                all: flags.all,
+                force: flags.force,
+                dryRun: flags.dryRun,
+            });
+            break;
+        }
+        default:
+            error(`Unknown command: ${subcommand}`);
+            log(HELP);
+            process.exit(1);
+    }
+}
+main().catch((err) => {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/metadata.d.ts

@@ -0,0 +1,17 @@
+export interface GitHubMetadata {
+    source_type: "github";
+    source_url: string;
+    github_commit: string;
+    installed_at: string;
+    updated_at: string;
+}
+export interface LocalMetadata {
+    source_type: "local";
+    source_path: string;
+    local_git_commit?: string;
+    installed_at: string;
+    updated_at: string;
+}
+export type SkillMetadata = GitHubMetadata | LocalMetadata;
+export declare function writeMetadata(skillDir: string, metadata: SkillMetadata): void;
+export declare function readMetadata(skillDir: string): SkillMetadata | null;

package/dist/metadata.js

@@ -0,0 +1,15 @@
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+const METADATA_FILE = ".metadata.json";
+export function writeMetadata(skillDir, metadata) {
+    const filePath = join(skillDir, METADATA_FILE);
+    writeFileSync(filePath, JSON.stringify(metadata, null, 2) + "\n");
+}
+export function readMetadata(skillDir) {
+    const filePath = join(skillDir, METADATA_FILE);
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+}

package/dist/sources/github.d.ts

@@ -0,0 +1,9 @@
+export interface GitHubParsed {
+    owner: string;
+    repo: string;
+    branch: string;
+    path: string;
+}
+export declare function parseGitHubUrl(url: string): GitHubParsed;
+export declare function downloadSkill(parsed: GitHubParsed, destDir: string): Promise<void>;
+export declare function fetchLatestCommit(parsed: GitHubParsed): Promise<string>;

package/dist/sources/github.js

@@ -0,0 +1,74 @@
+import { mkdtempSync, existsSync, readdirSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { execFileSync } from "child_process";
+export function parseGitHubUrl(url) {
+    const cleaned = url.replace(/\/+$/, "");
+    const match = cleaned.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/);
+    if (!match) {
+        throw new Error(`Invalid GitHub URL format. Expected: https://github.com/owner/repo/tree/branch/path/to/skill`);
+    }
+    return {
+        owner: match[1],
+        repo: match[2],
+        branch: match[3],
+        path: match[4],
+    };
+}
+export async function downloadSkill(parsed, destDir) {
+    const tarballUrl = `https://github.com/${parsed.owner}/${parsed.repo}/archive/refs/heads/${parsed.branch}.tar.gz`;
+    const tarballPrefix = `${parsed.repo}-${parsed.branch}`;
+    const stripComponents = parsed.path.split("/").length + 1;
+    const tmpDir = mkdtempSync(join(tmpdir(), "skillmanager-"));
+    try {
+        // Download tarball
+        const response = await fetch(tarballUrl);
+        if (!response.ok) {
+            throw new Error(`Failed to download tarball: ${response.status} ${response.statusText}`);
+        }
+        const tarballPath = join(tmpDir, "archive.tar.gz");
+        writeFileSync(tarballPath, Buffer.from(await response.arrayBuffer()));
+        // Extract the specific subdirectory
+        try {
+            execFileSync("tar", [
+                "xzf",
+                tarballPath,
+                "-C",
+                destDir,
+                `--strip-components=${stripComponents}`,
+                `${tarballPrefix}/${parsed.path}`,
+            ]);
+        }
+        catch (err) {
+            throw new Error(`Failed to extract tarball: ${err.stderr?.toString() ?? err.message}`);
+        }
+        // Verify something was extracted
+        if (!existsSync(destDir) || readdirSync(destDir).length === 0) {
+            throw new Error("Extraction produced no files. Check that the URL, branch, and path are correct.");
+        }
+    }
+    finally {
+        // Clean up temp tarball
+        rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+export async function fetchLatestCommit(parsed) {
+    const apiUrl = `https://api.github.com/repos/${parsed.owner}/${parsed.repo}/commits?sha=${parsed.branch}&path=${parsed.path}&per_page=1`;
+    const headers = {
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "skillmanager",
+    };
+    const token = process.env.GITHUB_TOKEN;
+    if (token) {
+        headers["Authorization"] = `token ${token}`;
+    }
+    const response = await fetch(apiUrl, { headers });
+    if (!response.ok) {
+        throw new Error(`GitHub API request failed: ${response.status} ${response.statusText}`);
+    }
+    const commits = (await response.json());
+    if (!commits.length) {
+        throw new Error(`No commits found for path '${parsed.path}'`);
+    }
+    return commits[0].sha;
+}

package/dist/sources/local.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveLocalPath(source: string): string;
+export declare function getGitCommit(dirPath: string): string | null;

package/dist/sources/local.js

@@ -0,0 +1,23 @@
+import { existsSync, realpathSync } from "fs";
+import { resolve } from "path";
+import { execFileSync } from "child_process";
+export function resolveLocalPath(source) {
+    // Expand ~ to home directory
+    const expanded = source.replace(/^~/, process.env.HOME || "");
+    const resolved = resolve(expanded);
+    if (!existsSync(resolved)) {
+        throw new Error(`Local path does not exist: ${source}`);
+    }
+    return realpathSync(resolved);
+}
+export function getGitCommit(dirPath) {
+    try {
+        const output = execFileSync("git", ["-C", dirPath, "rev-parse", "HEAD"], {
+            encoding: "utf-8",
+        });
+        return output.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const SKILLS_DIR: string;
+export declare function validateSkillDir(dir: string): void;
+export declare function log(message: string): void;
+export declare function info(message: string): void;
+export declare function error(message: string): void;
+export declare function success(message: string): void;

package/dist/utils.js

@@ -0,0 +1,22 @@
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+export const SKILLS_DIR = join(homedir(), ".claude", "skills");
+export function validateSkillDir(dir) {
+    const skillMd = join(dir, "SKILL.md");
+    if (!existsSync(skillMd)) {
+        throw new Error(`No SKILL.md found in '${dir}'. This does not appear to be a valid skill directory.`);
+    }
+}
+export function log(message) {
+    console.log(message);
+}
+export function info(message) {
+    console.log(`\x1b[36m${message}\x1b[0m`);
+}
+export function error(message) {
+    console.error(`\x1b[31mError: ${message}\x1b[0m`);
+}
+export function success(message) {
+    console.log(`\x1b[32m${message}\x1b[0m`);
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@tomaskral/skillmanager",
+  "version": "0.1.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kadel/skillmanager.git"
+  },
+  "bin": {
+    "skillmanager": "dist/index.js"
+  },
+  "files": ["dist"],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "semantic-release": "^24.0.0",
+    "typescript": "^5.9.3"
+  }
+}