Add skills from a GitHub repo, re-enable a previously disabled skill, or add a skill from a specific plugin. The positional argument is interpreted by context:

| `--skill <names>` | Comma-separated skill names to install when the positional is a plugin source |

| `--all` | Install every skill from the source |

| `--list` | List available skills at the source without installing |

Pass `owner/repo` directly with no flags — all skills in that repo are installed automatically. This mirrors how `npx skills add` treats a package as a transport for its skills, not a named entity:

allagents skill add ReScienceLab/opc-skills

allagents skill add https://github.com/owner/repo

allagents skill add gh:owner/repo

This works for:

- **Standalone skill repos** — a single `SKILL.md` at the root (no `skills/` subdirectory)

- **Multi-skill bundles** — repos with a `skills/` directory containing multiple skill files

Use `--list` first to preview what's available before installing:

allagents skill add ReScienceLab/opc-skills --list

To install only one skill from a multi-skill repo:

allagents skill add ReScienceLab/opc-skills --skill reddit

To install multiple by name:

allagents skill add ReScienceLab/opc-skills --skill reddit,terraform

To install a skill from a specific file URL:

allagents skill add https://github.com/owner/repo/tree/main/skills/my-skill

| { shape: 'source'; skills: string[] }

| { shape: 'source-auto' } {

if (isGitHubUrl(positional)) {

if (hasSelector) return { shape: 'source', skills };

// No subpath → the repo is a standalone skill or skill bundle; auto-install all.

// Subpath → legacy deep-URL form handled by resolveSkillFromUrl.

if (!parseGitHubUrl(positional)?.subpath) return { shape: 'source-auto' };

async function selectAndInstallSkillsFromSource(opts: {

from: string;

isUser: boolean;

workspacePath: string;

}): Promise<

| { success: true; installed: Array<{ pluginName: string; skills: string[] }>; syncResult: SyncResult }

| { success: false; error: string }

| { success: 'cancelled' }

> {

const { from, isUser, workspacePath } = opts;

const isTTY = process.stdout.isTTY && process.stdin.isTTY;

// Non-interactive path: install everything silently

if (!isTTY || isJsonMode()) {

return installAllSkillsFromSource(opts);

}

// Discover available skills (fetches the repo)

const discovered = await discoverSkillsFromSource(from);

if (!discovered.success) return { success: false, error: discovered.error };

if (discovered.skills.length === 0) {

return { success: false, error: `No skills found in '${from}'.` };

}

// Marketplace repos or single-skill repos: skip the picker

if (discovered.isMarketplace || discovered.skills.length === 1) {

return installAllSkillsFromSource(opts);

}

// Multiple skills on a direct repo: show a multiselect with all pre-selected

const p = await import('@clack/prompts');

const allNames = discovered.skills.map((s) => s.name);

const options = discovered.skills.map((s) => ({

label: s.name,

value: s.name,

...(s.description ? { hint: s.description } : {}),

}));

const selected = await p.autocompleteMultiselect({

message: `Select skills to install from ${chalk.bold(from)}`,

options,

initialValues: allNames,

placeholder: 'Type to filter · Space to toggle · Enter to confirm',

required: false,

});

if (p.isCancel(selected) || (selected as string[]).length === 0) {

return { success: 'cancelled' };

}

const selectedNames = selected as string[];

// All skills selected: use the efficient bulk path

if (selectedNames.length === allNames.length) {

return installAllSkillsFromSource(opts);

}

// Subset selected: configure allowlist with just those names, then sync once

const parsed = isGitHubUrl(from) ? parseGitHubUrl(from) : null;

const fetchResult = await fetchPlugin(from, {

...(parsed?.branch && { branch: parsed.branch }),

});

if (!fetchResult.success) {

return {

success: false,

error: `Failed to fetch '${from}': ${fetchResult.error ?? 'Unknown error'}`,

};

}

const existingEnabled = await getEnabledSkillsForGitHubSource(from, workspacePath);

const desiredSkills = [...existingEnabled];

for (const name of selectedNames) {

if (!desiredSkills.includes(name)) desiredSkills.push(name);

}

const updateResult = isUser

? await upsertUserGitHubPluginSourceAllowlist(from, desiredSkills)

: await upsertGitHubPluginSourceAllowlist(from, desiredSkills, workspacePath);

if (!updateResult.success) {

return {

success: false,

error: `Failed to configure skill allowlist: ${updateResult.error ?? 'Unknown error'}`,

};

}

const pluginName = extractPrimaryPluginName(updateResult.normalizedPlugin ?? from);

console.log(

`✓ Enabled ${selectedNames.length} skill(s) from ${pluginName}: ${selectedNames.join(', ')}`,

);

const syncResult = isUser

? await syncUserWorkspace()

: await syncWorkspace(workspacePath);

if (!syncResult.success) return { success: false, error: 'Sync failed' };

return {

success: true,

installed: [{ pluginName, skills: desiredSkills }],

syncResult,

};

// Classify the positional argument so we know which code path to take.

// source-auto: bare owner/repo (no subpath, no selector) — install all skills

// from the repo as if --all were passed. Mirrors `npx skills add owner/repo`.

let autoAll = false;

if (classified.shape === 'source' || classified.shape === 'source-auto') {

if (classified.shape === 'source') {

skillsFromFlag = classified.skills;

} else {

autoAll = true;

}

// --all or auto-install (bare owner/repo with no selector): bulk install

if (all || autoAll) {

// source-auto: interactive picker on TTY; --all: direct bulk install

const installResult = autoAll

? await selectAndInstallSkillsFromSource({

from: fromArg,

isUser: isUserAll,

workspacePath: workspacePathAll,

})

: await installAllSkillsFromSource({

from: fromArg,

isUser: isUserAll,

workspacePath: workspacePathAll,

});

if (installResult.success === 'cancelled') {

return;

}

'allagents skill add ReScienceLab/opc-skills',

'A skill name (re-enable an installed skill, or pair with --from to install from a source); ' +

'a plugin source without subpath (owner/repo, gh:owner/repo, or https://github.com/owner/repo — ' +

'installs all skills from that repo without needing any flags); ' +

'or a deep GitHub URL with a subpath pointing to a specific skill file.',

// skill-first: bare owner/repo (no selector, no subpath) → auto-install all skills

it('auto-installs all skills for bare owner/repo with no selector', () => {

expect(classifySkillAddPositional('ReScienceLab/opc-skills', undefined, false, false)).toEqual({

shape: 'source-auto',

});

});

it('auto-installs all skills for bare https://github.com/owner/repo with no selector', () => {

expect(

classifySkillAddPositional('https://github.com/owner/repo', undefined, false, false),

).toEqual({ shape: 'source-auto' });

});

it('auto-installs all skills for gh: shorthand with no selector', () => {

expect(classifySkillAddPositional('gh:owner/repo', undefined, false, false)).toEqual({

shape: 'source-auto',

});

});

it('falls back to skill-name for owner/repo with subpath (legacy deep-URL form)', () => {

// Subpath → handled by resolveSkillFromUrl as a specific skill install

expect(

classifySkillAddPositional('owner/repo/skills/my-skill', undefined, false, false),

).toEqual({ shape: 'skill-name' });

});

it('falls back to skill-name for full GitHub URL with subpath (legacy deep-URL form)', () => {