@goodboyjs/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GoodBoy Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,21 @@
+# @goodboyjs/cli
+
+The GoodBoy command-line interface — the `goodboy` binary.
+
+## Installation
+
+```sh
+npm install -g @goodboyjs/cli
+```
+
+## Commands
+
+See the [root README](../../README.md#commands) for the full command reference.
+
+## Development
+
+```sh
+npm run build   # compile TypeScript → dist/
+npm run dev     # run from source with tsx
+npm run test    # run the test suite
+```

package/dist/commands/add.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const addCommand: Command;

package/dist/commands/add.js

@@ -0,0 +1,100 @@
+import { Command } from 'commander';
+import { existsSync, mkdirSync, cpSync } from 'node:fs';
+import { resolve, basename, join } from 'node:path';
+import ora from 'ora';
+import { SKILL_NAME_RE } from '../lib/validation.js';
+import { validateSkillDirectory, formatValidationResult } from '../lib/skill-validator.js';
+import { readManifest, validateManifest } from '../lib/manifest.js';
+import { scanForSymlinks } from '../lib/fs-security.js';
+import { getRegistryPath, ensureRegistryExists } from '../lib/registry.js';
+import { readRegistryEntry, writeRegistryEntry, createRegistryEntry, addVersionToEntry, } from '../lib/registry-entry.js';
+import { logger } from '../lib/logger.js';
+/**
+ * Marks a failure branch that has already logged its own specific message
+ * (and, for validation failures, already printed the full issue list).
+ * The catch block below checks for this to avoid re-logging a second,
+ * misleading message before exiting.
+ */
+class HandledFailure extends Error {
+}
+export const addCommand = new Command('add')
+    .description('Add a skill to the local registry')
+    .argument('<skill-path>', 'Path to the skill directory')
+    .option('-f, --force', 'Overwrite an existing version')
+    .action(async (skillPathArg, options) => {
+    const spinner = ora('Adding skill...').start();
+    try {
+        const skillPath = resolve(skillPathArg);
+        if (!existsSync(skillPath)) {
+            spinner.fail();
+            logger.error(`Skill path not found: "${skillPathArg}"`);
+            throw new HandledFailure();
+        }
+        const dirName = basename(skillPath);
+        if (!SKILL_NAME_RE.test(dirName)) {
+            spinner.fail();
+            logger.error(`Invalid skill directory name "${dirName}": must match ^[a-z0-9-]+$`);
+            throw new HandledFailure();
+        }
+        spinner.text = 'Validating skill directory...';
+        const result = await validateSkillDirectory(skillPath);
+        if (!result.valid) {
+            spinner.fail('Skill validation failed');
+            formatValidationResult(result, dirName);
+            throw new HandledFailure();
+        }
+        if (result.issues.some((i) => i.severity === 'warning')) {
+            spinner.stop();
+            formatValidationResult(result, dirName);
+            spinner.start('Continuing...');
+        }
+        spinner.text = 'Reading manifest...';
+        const rawManifest = await readManifest(join(skillPath, 'manifest.json'));
+        const manifest = validateManifest(rawManifest);
+        if (manifest.name !== dirName) {
+            spinner.fail();
+            logger.error(`Manifest name "${manifest.name}" does not match directory name "${dirName}"`);
+            throw new HandledFailure();
+        }
+        const version = manifest.version;
+        spinner.text = 'Scanning for symlinks...';
+        await scanForSymlinks(skillPath);
+        ensureRegistryExists();
+        const registryPath = getRegistryPath();
+        const skillRegistryDir = join(registryPath, manifest.name);
+        const versionRelPath = join('versions', version);
+        const versionAbsPath = join(skillRegistryDir, versionRelPath);
+        const existingEntry = await readRegistryEntry(skillRegistryDir);
+        if (existingEntry?.versions[version] !== undefined) {
+            if (!options.force) {
+                spinner.fail();
+                logger.error(`Version "${version}" of skill "${manifest.name}" already exists. Use --force to overwrite.`);
+                throw new HandledFailure();
+            }
+            logger.warn(`Overwriting existing version "${version}" of skill "${manifest.name}".`);
+        }
+        spinner.text = 'Copying skill files...';
+        mkdirSync(versionAbsPath, { recursive: true, mode: 0o700 });
+        cpSync(skillPath, versionAbsPath, { recursive: true });
+        if (!existsSync(skillRegistryDir)) {
+            mkdirSync(skillRegistryDir, { recursive: true, mode: 0o700 });
+        }
+        const entry = existingEntry
+            ? addVersionToEntry(existingEntry, version, versionRelPath)
+            : createRegistryEntry(manifest.name, version, versionRelPath);
+        await writeRegistryEntry(skillRegistryDir, entry);
+        spinner.succeed(`Skill "${manifest.name}@${version}" added to registry`);
+    }
+    catch (err) {
+        if (!(err instanceof HandledFailure)) {
+            spinner.fail();
+            if (err instanceof Error && err.message.toLowerCase().includes('symlink')) {
+                logger.error('Skill rejected: symlink pointing outside skill directory detected');
+            }
+            else {
+                logger.error(err instanceof Error ? err.message : 'Unknown error');
+            }
+        }
+        process.exit(1);
+    }
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const initCommand: Command;

package/dist/commands/init.js

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import { readGoodBoyJson, writeGoodBoyJson } from '../lib/goodboy-file.js';
+import { logger, sanitiseError } from '../lib/logger.js';
+export const initCommand = new Command('init')
+    .description('Initialise GoodBoy in the current directory (creates goodboy.json)')
+    .option('--registry <url>', 'Set a custom registry URL in goodboy.json')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    const existing = await readGoodBoyJson(cwd);
+    if (existing) {
+        logger.warn('goodboy.json already exists in this directory.');
+        logger.info("Run 'goodboy install <skill-name>' to add a skill.");
+        process.exit(0);
+        return;
+    }
+    const data = {
+        schema: '1.0.0',
+        ...(options.registry ? { registry: options.registry } : {}),
+        skills: {},
+    };
+    try {
+        await writeGoodBoyJson(cwd, data);
+    }
+    catch (err) {
+        logger.error(sanitiseError(err));
+        process.exit(1);
+        return;
+    }
+    logger.success(`Initialised goodboy.json in ${cwd}`);
+    logger.info("Run 'goodboy install <skill-name>' to add a skill.");
+    logger.info("Run 'goodboy skill create' to scaffold a new skill.");
+});

package/dist/commands/install.d.ts

@@ -0,0 +1,13 @@
+import { Command } from 'commander';
+export interface InstallOptions {
+    global?: boolean;
+    /** Set to false when Commander sees --no-commit (Commander maps --no-x to options.x = false) */
+    commit?: boolean;
+    claudeCode?: boolean;
+    codex?: boolean;
+    gemini?: boolean;
+    allAgents?: boolean;
+}
+export declare function installNamed(name: string, options: InstallOptions, cwd: string): Promise<void>;
+export declare function installFromManifest(options: InstallOptions, cwd: string): Promise<void>;
+export declare const installCommand: Command;

package/dist/commands/install.js

@@ -0,0 +1,192 @@
+import { Command } from 'commander';
+import { cpSync, mkdirSync, existsSync, statSync } from 'node:fs';
+import { appendFile, readFile } from 'node:fs/promises';
+import { join, sep } from 'node:path';
+import ora from 'ora';
+import { createRegistryAdapter } from '../lib/registry-adapter.js';
+import { readManifest, validateManifest } from '../lib/manifest.js';
+import { requestConsent } from '../lib/consent.js';
+import { scanForSymlinks } from '../lib/fs-security.js';
+import { logger, sanitiseError } from '../lib/logger.js';
+import { SKILL_NAME_RE } from '../lib/validation.js';
+import { readGoodBoyJson, addSkillToManifest, addSkillToLock, } from '../lib/goodboy-file.js';
+import { resolveAgentFlags, createAgentSymlinks } from '../lib/agents.js';
+import { installToStore, getGoodboyHome } from '../lib/store.js';
+// Skills readable by Claude Code (group/world read allowed)
+const PROJECT_SKILLS_DIR_MODE = 0o755;
+function getProjectSkillsPath(cwd) {
+    return join(cwd, '.claude', 'skills');
+}
+async function ensureGitignoreEntry(cwd) {
+    const gitignorePath = join(cwd, '.gitignore');
+    const entry = '.claude/skills/';
+    let existing = '';
+    try {
+        existing = await readFile(gitignorePath, 'utf-8');
+    }
+    catch {
+        // .gitignore doesn't exist yet — will be created
+    }
+    const lines = existing.split('\n');
+    if (!lines.some((l) => l.trim() === entry)) {
+        const prefix = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+        await appendFile(gitignorePath, `${prefix}${entry}\n`, 'utf-8');
+        logger.info(`Added "${entry}" to .gitignore`);
+    }
+}
+async function installNamedProject(name, skillPath, cwd) {
+    const skillsPath = getProjectSkillsPath(cwd);
+    const destPath = join(skillsPath, name);
+    // Traversal guard
+    if (!destPath.startsWith(skillsPath + sep) && destPath !== skillsPath) {
+        throw new Error('Refused: destination path escapes the skills directory');
+    }
+    if (existsSync(destPath)) {
+        const s = statSync(destPath);
+        if (!s.isDirectory()) {
+            throw new Error('Refused: destination path exists but is not a directory');
+        }
+    }
+    mkdirSync(skillsPath, { recursive: true, mode: PROJECT_SKILLS_DIR_MODE });
+    if (existsSync(destPath)) {
+        cpSync(skillPath, destPath, { recursive: true, force: true });
+    }
+    else {
+        cpSync(skillPath, destPath, { recursive: true });
+    }
+    return destPath;
+}
+export async function installNamed(name, options, cwd) {
+    if (!SKILL_NAME_RE.test(name)) {
+        throw new Error(`Invalid skill name: "${name}". Must match ^[a-z0-9-]+$.`);
+    }
+    const registry = createRegistryAdapter();
+    const spinner = ora(`Resolving "${name}"…`).start();
+    let skillPath;
+    try {
+        skillPath = await registry.resolveSkill(name);
+    }
+    catch (err) {
+        spinner.fail(`Cannot locate skill "${name}"`);
+        throw err;
+    }
+    let manifest;
+    try {
+        const data = await readManifest(join(skillPath, 'manifest.json'));
+        manifest = validateManifest(data);
+    }
+    catch (err) {
+        spinner.fail('Manifest validation failed');
+        throw err;
+    }
+    if (manifest.name !== name) {
+        logger.info(`Note: manifest declares name "${manifest.name}", installing as "${name}".`);
+    }
+    spinner.stop();
+    const consented = await requestConsent(manifest);
+    if (!consented) {
+        logger.warn('Installation cancelled.');
+        return;
+    }
+    spinner.start(`Installing "${name}"…`);
+    try {
+        await scanForSymlinks(skillPath);
+    }
+    catch {
+        spinner.fail('Symlink check failed');
+        throw new Error('Skill rejected: symlink pointing outside skill directory detected');
+    }
+    let resolvedPath;
+    if (options.global) {
+        let storePath;
+        try {
+            storePath = await installToStore(name, skillPath);
+        }
+        catch (err) {
+            spinner.fail('Failed to install to store');
+            throw err;
+        }
+        const agents = resolveAgentFlags({
+            claudeCode: options.claudeCode,
+            codex: options.codex,
+            gemini: options.gemini,
+            allAgents: options.allAgents,
+        });
+        try {
+            await createAgentSymlinks({ agents, skillName: name, storePath });
+        }
+        catch (err) {
+            spinner.fail('Failed to create agent symlinks');
+            throw err;
+        }
+        resolvedPath = storePath;
+        const goodboyHome = getGoodboyHome();
+        await addSkillToManifest(goodboyHome, name, manifest.version);
+        await addSkillToLock(goodboyHome, name, manifest.version, resolvedPath);
+    }
+    else {
+        try {
+            resolvedPath = await installNamedProject(name, skillPath, cwd);
+        }
+        catch (err) {
+            spinner.fail('Failed to copy skill files');
+            throw err;
+        }
+        if (options.commit === false) {
+            await ensureGitignoreEntry(cwd);
+        }
+        await addSkillToManifest(cwd, name, manifest.version);
+        await addSkillToLock(cwd, name, manifest.version, resolvedPath);
+    }
+    spinner.succeed(`Installed "${name}" (${manifest.version})`);
+}
+export async function installFromManifest(options, cwd) {
+    const goodboy = await readGoodBoyJson(cwd);
+    if (!goodboy) {
+        throw new Error('No goodboy.json found in current directory. Run "goodboy install <skill-name>" to install a skill.');
+    }
+    const skills = Object.keys(goodboy.skills);
+    if (skills.length === 0) {
+        logger.info('No skills listed in goodboy.json.');
+        return;
+    }
+    const skillsPath = options.global ? undefined : getProjectSkillsPath(cwd);
+    const missing = skills.filter((name) => {
+        if (skillsPath === undefined)
+            return true;
+        return !existsSync(join(skillsPath, name));
+    });
+    if (missing.length === 0) {
+        logger.info('All skills already installed.');
+        return;
+    }
+    logger.info(`Installing ${missing.length} skill(s)…`);
+    for (const name of missing) {
+        await installNamed(name, options, cwd);
+    }
+}
+export const installCommand = new Command('install')
+    .alias('i')
+    .description('Install a skill from the registry, or restore all from goodboy.json')
+    .argument('[skill-name]', 'Skill to install (omit to restore from goodboy.json)')
+    .option('-g, --global', 'Install to global store (~/.goodboy/skills/)')
+    .option('--no-commit', 'Add .claude/skills/ to .gitignore (goodboy.json/lock are still written)')
+    .option('--claude-code', 'Link into ~/.claude/skills/ (default when -g and no agent flag)')
+    .option('--codex', 'Link into ~/.codex/skills/')
+    .option('--gemini', 'Link into ~/.gemini/skills/')
+    .option('--all-agents', 'Link into all agent skill directories')
+    .action(async (skillName, options) => {
+    const cwd = process.cwd();
+    try {
+        if (skillName !== undefined) {
+            await installNamed(skillName, options, cwd);
+        }
+        else {
+            await installFromManifest(options, cwd);
+        }
+    }
+    catch (err) {
+        logger.error(sanitiseError(err));
+        process.exit(1);
+    }
+});

package/dist/commands/list.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const listCommand: Command;

package/dist/commands/list.js

@@ -0,0 +1,106 @@
+import { Command } from 'commander';
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import Table from 'cli-table3';
+import chalk from 'chalk';
+import { createRegistryAdapter } from '../lib/registry-adapter.js';
+import { readManifest, validateManifest } from '../lib/manifest.js';
+import { readGoodBoyJson } from '../lib/goodboy-file.js';
+import { logger, sanitiseError } from '../lib/logger.js';
+function statusColor(status) {
+    switch (status) {
+        case 'stable': return chalk.green(status);
+        case 'experimental': return chalk.yellow(status);
+        case 'deprecated': return chalk.red(status);
+        default: return chalk.gray(status);
+    }
+}
+function scopeColor(scope) {
+    return scope === 'project' ? chalk.cyan(scope) : chalk.magenta(scope);
+}
+async function readSkillsFromDir(dir, scope) {
+    if (!existsSync(dir))
+        return [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    const rows = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const manifestPath = join(dir, entry.name, 'manifest.json');
+        try {
+            const data = await readManifest(manifestPath);
+            const manifest = validateManifest(data);
+            rows.push({ manifest, scope });
+        }
+        catch {
+            // silently skip unreadable/invalid skills
+        }
+    }
+    return rows;
+}
+async function run(options) {
+    const cwd = process.cwd();
+    const rows = [];
+    const showProject = !options.global || options.all;
+    const showGlobal = options.global === true || options.all === true;
+    if (showProject) {
+        const hasGoodBoyJson = (await readGoodBoyJson(cwd)) !== null;
+        if (!hasGoodBoyJson) {
+            if (options.all) {
+                logger.info('Project skills: no goodboy.json in this directory');
+            }
+            else {
+                logger.warn('No goodboy.json found in current directory.');
+                logger.info("This doesn't look like a GoodBoy project.");
+                logger.info('');
+                logger.info("Run 'goodboy init' to initialise GoodBoy here.");
+                logger.info("Run 'goodboy list -g' to see globally installed skills.");
+                return;
+            }
+        }
+        else {
+            const projectSkillsPath = join(cwd, '.claude', 'skills');
+            rows.push(...(await readSkillsFromDir(projectSkillsPath, 'project')));
+        }
+    }
+    if (showGlobal) {
+        const registry = createRegistryAdapter();
+        const globalSkillsPath = registry.getSkillsLocation();
+        rows.push(...(await readSkillsFromDir(globalSkillsPath, 'global')));
+    }
+    if (rows.length === 0) {
+        logger.info('No skills installed. Run `goodboy install <name>` to get started.');
+        return;
+    }
+    const table = new Table({
+        head: ['Name', 'Version', 'Description', 'Status', 'Scope'].map((h) => chalk.bold(h)),
+        colWidths: [20, 10, 36, 14, 10],
+        wordWrap: true,
+        style: { head: [], border: [] },
+    });
+    for (const { manifest, scope } of rows) {
+        table.push([
+            chalk.white(manifest.name),
+            chalk.gray(manifest.version),
+            manifest.description,
+            statusColor(manifest.status),
+            scopeColor(scope),
+        ]);
+    }
+    process.stdout.write(table.toString() + '\n');
+    logger.info(`\n${rows.length} skill${rows.length === 1 ? '' : 's'} installed`);
+}
+export const listCommand = new Command('list')
+    .description('List installed skills')
+    .option('-g, --global', 'List only globally installed skills')
+    .option('-a, --all', 'List both project and global skills')
+    .action(async (options) => {
+    try {
+        await run(options);
+    }
+    catch (err) {
+        logger.error(sanitiseError(err));
+        process.exit(1);
+    }
+});

package/dist/commands/registry-cmd.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const registryCommand: Command;

package/dist/commands/registry-cmd.js

@@ -0,0 +1,122 @@
+import { Command } from 'commander';
+import { join } from 'node:path';
+import { existsSync, rmSync } from 'node:fs';
+import { createRegistryAdapter } from '../lib/registry-adapter.js';
+import { validateSkillDirectory, formatValidationResult } from '../lib/skill-validator.js';
+import { getRegistryPath, resolveSkill, } from '../lib/registry.js';
+import { readRegistryEntry, writeRegistryEntry, resolveLatestVersion, } from '../lib/registry-entry.js';
+import { SKILL_NAME_RE } from '../lib/validation.js';
+import { logger } from '../lib/logger.js';
+export const registryCommand = new Command('registry')
+    .description('Manage the local skill registry');
+registryCommand
+    .command('list')
+    .description('List all registered skills')
+    .action(async () => {
+    const adapter = createRegistryAdapter();
+    const entries = await adapter.listRegistry();
+    if (entries.length === 0) {
+        logger.info('Registry is empty. Use `goodboy add <skill-path>` to add skills.');
+        return;
+    }
+    for (const entry of entries) {
+        const latest = resolveLatestVersion(entry) ?? '(none)';
+        const versionCount = Object.keys(entry.versions).length;
+        logger.info(`${entry.name}  latest: ${latest}  (${versionCount} version${versionCount === 1 ? '' : 's'})`);
+    }
+});
+registryCommand
+    .command('info <skill>')
+    .description('Show details about a registered skill')
+    .action(async (skillName) => {
+    if (!SKILL_NAME_RE.test(skillName)) {
+        logger.error(`Invalid skill name "${skillName}": must match ^[a-z0-9-]+$`);
+        process.exit(1);
+    }
+    const registryPath = getRegistryPath();
+    const skillDir = join(registryPath, skillName);
+    const entry = await readRegistryEntry(skillDir);
+    if (!entry) {
+        logger.error(`Skill "${skillName}" not found in registry`);
+        process.exit(1);
+    }
+    logger.info(`Name:    ${entry.name}`);
+    logger.info(`Latest:  ${entry.latest}`);
+    logger.info('Versions:');
+    for (const [ver, info] of Object.entries(entry.versions)) {
+        const yankedLabel = info.yanked ? ' [yanked]' : '';
+        logger.info(`  ${ver}${yankedLabel}  added: ${info.addedAt}`);
+    }
+});
+registryCommand
+    .command('validate <skill>')
+    .description('Validate a registered skill\'s structure')
+    .action(async (skillName) => {
+    if (!SKILL_NAME_RE.test(skillName)) {
+        logger.error(`Invalid skill name "${skillName}": must match ^[a-z0-9-]+$`);
+        process.exit(1);
+    }
+    let skillPath;
+    try {
+        skillPath = await resolveSkill(skillName);
+    }
+    catch (err) {
+        logger.error(err instanceof Error ? err.message : `Skill "${skillName}" not found`);
+        process.exit(1);
+    }
+    const result = await validateSkillDirectory(skillPath);
+    formatValidationResult(result, skillName);
+    if (result.valid) {
+        logger.success(`Skill "${skillName}" is valid`);
+    }
+    else {
+        process.exit(1);
+    }
+});
+registryCommand
+    .command('remove <skill>')
+    .description('Remove a skill (or specific version) from the registry')
+    .option('--version <version>', 'Remove only this version (default: remove all versions)')
+    .action(async (skillName, options) => {
+    if (!SKILL_NAME_RE.test(skillName)) {
+        logger.error(`Invalid skill name "${skillName}": must match ^[a-z0-9-]+$`);
+        process.exit(1);
+    }
+    const registryPath = getRegistryPath();
+    const skillDir = join(registryPath, skillName);
+    const entry = await readRegistryEntry(skillDir);
+    if (!entry) {
+        logger.error(`Skill "${skillName}" not found in registry`);
+        process.exit(1);
+    }
+    if (options.version) {
+        const ver = options.version;
+        if (!entry.versions[ver]) {
+            logger.error(`Version "${ver}" of skill "${skillName}" not found in registry`);
+            process.exit(1);
+        }
+        const versionPath = join(skillDir, entry.versions[ver].path);
+        if (existsSync(versionPath)) {
+            rmSync(versionPath, { recursive: true, force: true });
+        }
+        const { [ver]: _removed, ...remainingVersions } = entry.versions;
+        const remainingKeys = Object.keys(remainingVersions);
+        if (remainingKeys.length === 0) {
+            rmSync(skillDir, { recursive: true, force: true });
+            logger.success(`Skill "${skillName}" removed from registry (last version deleted)`);
+        }
+        else {
+            const newLatest = resolveLatestVersion({ ...entry, versions: remainingVersions }) ?? remainingKeys[0];
+            await writeRegistryEntry(skillDir, {
+                ...entry,
+                latest: newLatest,
+                versions: remainingVersions,
+            });
+            logger.success(`Version "${ver}" of skill "${skillName}" removed`);
+        }
+    }
+    else {
+        rmSync(skillDir, { recursive: true, force: true });
+        logger.success(`Skill "${skillName}" removed from registry`);
+    }
+});

package/dist/commands/search.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const searchCommand: Command;