@agentskill.sh/cli 1.0.8 → 2.0.0

package/dist/commands/setup.js

@@ -1,41 +1,109 @@
-import { installCommand } from './install.js';
-// Official skills bundled with the ags CLI
-const OFFICIAL_SKILLS = [
-    'agentskill-sh/learn',
-    'agentskill-sh/review-skill',
-];
-export async function setupCommand(args) {
-    const jsonFlag = args.includes('--json');
-    const results = [];
-    if (!jsonFlag) {
-        console.log(`\nInstalling ${OFFICIAL_SKILLS.length} official skills...\n`);
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { apiFetch } from '../api.js';
+import { showLogo, ORANGE } from '../ui.js';
+import { detectInstalledAgents, getUniversalAgents, getNonUniversalAgents, getAgentDisplayName, } from '../agents.js';
+import { installToAgents } from '../installer.js';
+import { addToLock, saveSelectedAgents } from '../skill-lock.js';
+const OFFICIAL_SKILLS = ['agentskill-sh/learn', 'agentskill-sh/review-skill'];
+export async function setupCommand(_args) {
+    showLogo();
+    // Detect installed agents
+    const s = p.spinner();
+    s.start('Detecting installed agents...');
+    const installedAgents = await detectInstalledAgents();
+    if (!installedAgents.length) {
+        s.stop('No agents detected');
+        p.log.warn('No AI agents detected on this machine.');
+        p.log.info(`We will install to ${pc.bold('Claude Code')} by default. You can change this later.`);
+        installedAgents.push('claude-code');
     }
-    // Temporarily suppress console.log from installCommand --json output
-    const origLog = console.log;
+    else {
+        s.stop(`Found ${installedAgents.length} agent${installedAgents.length !== 1 ? 's' : ''}`);
+    }
+    // Show agent selection
+    const universal = getUniversalAgents().filter((a) => installedAgents.includes(a));
+    const nonUniversal = getNonUniversalAgents().filter((a) => installedAgents.includes(a));
+    // Build options
+    const options = [
+        ...universal.map((a) => ({
+            value: a,
+            label: `${getAgentDisplayName(a)} ${pc.dim('(.agents/skills)')}`,
+            hint: 'universal',
+        })),
+        ...nonUniversal.map((a) => ({
+            value: a,
+            label: getAgentDisplayName(a),
+        })),
+    ];
+    let selectedAgents;
+    if (options.length > 1) {
+        const selected = await p.multiselect({
+            message: 'Select agents to install skills to:',
+            options,
+            initialValues: installedAgents,
+            required: true,
+        });
+        if (p.isCancel(selected)) {
+            p.cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        selectedAgents = selected;
+    }
+    else {
+        selectedAgents = installedAgents;
+        p.log.step(`Installing to ${pc.bold(getAgentDisplayName(installedAgents[0]))}`);
+    }
+    // Save selected agents
+    saveSelectedAgents(selectedAgents);
+    // Install official skills
+    p.log.step(`Installing ${OFFICIAL_SKILLS.length} official skill${OFFICIAL_SKILLS.length !== 1 ? 's' : ''}...`);
     for (const slug of OFFICIAL_SKILLS) {
+        const spin = p.spinner();
+        spin.start(`Fetching ${slug}...`);
         try {
-            console.log = () => { }; // suppress install JSON output
-            await installCommand([slug, '--json']);
-            console.log = origLog;
-            results.push({ slug, status: 'installed' });
-            if (!jsonFlag) {
-                console.log(`  Installed: ${slug}`);
+            const data = await apiFetch(`/agent/skills/${encodeURIComponent(slug)}/install`);
+            if (!data.skillMd) {
+                spin.error(`${slug} has no SKILL.md`);
+                continue;
+            }
+            spin.stop(`Fetched ${ORANGE(data.name)}`);
+            const results = installToAgents(data, selectedAgents);
+            const successful = results.filter((r) => r.success);
+            if (successful.length) {
+                addToLock(data.slug, data.contentSha || '', selectedAgents);
+                p.log.success(`${ORANGE(data.name)} installed to ${successful.length} agent${successful.length !== 1 ? 's' : ''}`);
+            }
+            const failed = results.filter((r) => !r.success);
+            for (const r of failed) {
+                p.log.warn(`Failed for ${getAgentDisplayName(r.agent)}: ${r.error}`);
             }
         }
         catch (err) {
-            console.log = origLog;
-            const msg = err instanceof Error ? err.message : String(err);
-            results.push({ slug, status: `failed: ${msg}` });
-            if (!jsonFlag) {
-                console.error(`  Failed: ${slug} - ${msg}`);
-            }
+            spin.error(`Failed to install ${slug}`);
+            p.log.error(err instanceof Error ? err.message : String(err));
         }
     }
-    if (jsonFlag) {
-        console.log(JSON.stringify({ skills: results }, null, 2));
-    }
-    else {
-        console.log(`\nDone. ${results.filter((r) => r.status === 'installed').length}/${OFFICIAL_SKILLS.length} skills installed.`);
-        console.log('Restart your agent or open a new session to activate.');
+    // Offer to install globally
+    console.log();
+    const installGlobal = await p.confirm({
+        message: 'Install ags globally? (npm install -g @agentskill.sh/cli)',
+        initialValue: false,
+    });
+    if (!p.isCancel(installGlobal) && installGlobal) {
+        const gs = p.spinner();
+        gs.start('Installing globally...');
+        try {
+            const { execSync } = await import('child_process');
+            execSync('npm install -g @agentskill.sh/cli', { stdio: 'pipe' });
+            gs.stop('Installed globally');
+            p.log.success('You can now use `ags` from anywhere.');
+        }
+        catch {
+            gs.error('Global install failed');
+            p.log.info('You can install manually: npm install -g @agentskill.sh/cli');
+        }
     }
+    console.log();
+    p.outro(pc.green('Setup complete! Restart your agent to use the new skills.'));
 }

package/dist/commands/update.js

@@ -1,133 +1,103 @@
-import { readdir, readFile, rm } from 'fs/promises';
-import { join } from 'path';
-import { existsSync } from 'fs';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
 import { apiFetch } from '../api.js';
-import { detectSkillDir } from '../platform.js';
-import { installCommand } from './install.js';
-function parseHeader(content) {
-    const meta = {};
-    const lines = content.split('\n');
-    let inHeader = false;
-    for (const line of lines) {
-        if (line.trim() === '# --- agentskill.sh ---') {
-            inHeader = true;
-            continue;
-        }
-        if (line.trim() === '# ---')
-            break;
-        if (inHeader && line.startsWith('# ')) {
-            const match = line.match(/^# (\w+): (.+)$/);
-            if (match)
-                meta[match[1]] = match[2];
-        }
-    }
-    return meta;
-}
-async function scanInstalled(baseDir) {
-    const skills = [];
-    async function scan(dir, depth) {
-        if (depth > 2)
-            return;
-        const entries = await readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            const entryPath = join(dir, entry.name);
-            const skillMdPath = join(entryPath, 'SKILL.md');
-            if (existsSync(skillMdPath)) {
-                try {
-                    const content = await readFile(skillMdPath, 'utf-8');
-                    const meta = parseHeader(content);
-                    if (meta.slug) {
-                        skills.push({
-                            slug: meta.slug,
-                            owner: meta.owner || '',
-                            contentSha: meta.contentSha || '',
-                            dir: entryPath,
-                        });
-                    }
-                }
-                catch {
-                    // Skip unreadable
-                }
-            }
-            else {
-                await scan(entryPath, depth + 1);
-            }
-        }
-    }
-    await scan(baseDir, 0);
-    return skills;
-}
+import { readLock, addToLock } from '../skill-lock.js';
+import { installToAgents } from '../installer.js';
+import { getAgentDisplayName } from '../agents.js';
+import { ORANGE } from '../ui.js';
 export async function updateCommand(args) {
     const jsonFlag = args.includes('--json');
-    const baseDir = detectSkillDir();
-    if (!existsSync(baseDir)) {
-        if (jsonFlag) {
-            console.log(JSON.stringify({ updated: [], upToDate: 0 }));
-        }
-        else {
-            console.log('No skills installed.');
-        }
-        return;
-    }
-    const installed = await scanInstalled(baseDir);
+    const lock = readLock();
+    const installed = Object.values(lock.skills).filter((sk) => sk.slug && sk.contentSha);
     if (!installed.length) {
         if (jsonFlag) {
             console.log(JSON.stringify({ updated: [], upToDate: 0 }));
         }
         else {
-            console.log('No skills installed.');
+            p.log.warn('No skills installed.');
         }
         return;
     }
-    // Batch version check
-    const slugs = installed.map((s) => s.slug).join(',');
-    const remote = await apiFetch(`/agent/skills/version?slugs=${encodeURIComponent(slugs)}`);
+    const s = p.spinner();
+    s.start('Checking for updates...');
+    let remote;
+    try {
+        const slugs = installed.map((sk) => sk.slug).join(',');
+        remote = await apiFetch(`/agent/skills/version?slugs=${encodeURIComponent(slugs)}`);
+    }
+    catch (err) {
+        s.error('Failed to check versions');
+        throw err;
+    }
     const remoteMap = new Map(remote.map((r) => [r.slug, r.contentSha]));
-    const outdated = installed.filter((s) => remoteMap.has(s.slug) && remoteMap.get(s.slug) !== s.contentSha);
+    const outdated = installed.filter((sk) => remoteMap.has(sk.slug) && remoteMap.get(sk.slug) !== sk.contentSha);
     if (!outdated.length) {
+        s.stop(`All ${installed.length} skill${installed.length !== 1 ? 's' : ''} up to date`);
         if (jsonFlag) {
             console.log(JSON.stringify({ updated: [], upToDate: installed.length }));
         }
-        else {
-            console.log(`All ${installed.length} skill(s) are up to date.`);
-        }
         return;
     }
-    if (!jsonFlag) {
-        console.log(`\n${outdated.length} update(s) available:\n`);
-        for (const s of outdated) {
-            console.log(`  - ${s.slug}`);
-        }
-        console.log('');
-    }
-    const updated = [];
-    for (const s of outdated) {
-        try {
-            // Remove old version
-            await rm(s.dir, { recursive: true, force: true });
-            // Re-install via the install command
-            await installCommand([s.slug, '--json']);
-            updated.push(s.slug);
-            if (!jsonFlag) {
-                console.log(`  Updated: ${s.slug}`);
+    s.stop(`${outdated.length} update${outdated.length !== 1 ? 's' : ''} available`);
+    if (jsonFlag) {
+        // In JSON mode, proceed without confirmation
+        const updated = [];
+        for (const sk of outdated) {
+            try {
+                const data = await apiFetch(`/agent/skills/${encodeURIComponent(sk.slug)}/install`);
+                const results = installToAgents(data, sk.agents);
+                const successful = results.filter((r) => r.success);
+                if (successful.length) {
+                    addToLock(data.slug, data.contentSha || '', sk.agents);
+                    updated.push(sk.slug);
+                }
             }
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (!jsonFlag) {
-                console.error(`  Failed to update ${s.slug}: ${msg}`);
+            catch {
+                // Skip failed
             }
         }
-    }
-    if (jsonFlag) {
         console.log(JSON.stringify({
             updated,
             upToDate: installed.length - outdated.length,
         }, null, 2));
+        return;
     }
-    else {
-        console.log(`\nDone. ${updated.length} updated, ${installed.length - outdated.length} already current.`);
+    // Show what will be updated
+    for (const sk of outdated) {
+        const agentNames = sk.agents.map((a) => getAgentDisplayName(a)).join(', ');
+        p.log.info(`${ORANGE(sk.slug)} ${pc.dim(`(${agentNames})`)}`);
+    }
+    const proceed = await p.confirm({
+        message: `Update ${outdated.length} skill${outdated.length !== 1 ? 's' : ''}?`,
+    });
+    if (p.isCancel(proceed) || !proceed) {
+        p.cancel('Update cancelled.');
+        return;
+    }
+    // Update each skill
+    const updated = [];
+    for (const sk of outdated) {
+        const spin = p.spinner();
+        spin.start(`Updating ${sk.slug}...`);
+        try {
+            const data = await apiFetch(`/agent/skills/${encodeURIComponent(sk.slug)}/install`);
+            // Reinstall to the same agents
+            const results = installToAgents(data, sk.agents);
+            const successful = results.filter((r) => r.success);
+            if (successful.length) {
+                addToLock(data.slug, data.contentSha || '', sk.agents);
+                updated.push(sk.slug);
+                spin.stop(`Updated ${ORANGE(sk.slug)}`);
+            }
+            else {
+                spin.error(`Failed to update ${sk.slug}`);
+            }
+        }
+        catch (err) {
+            spin.error(`Failed to update ${sk.slug}`);
+            p.log.error(err instanceof Error ? err.message : String(err));
+        }
     }
+    console.log();
+    p.log.success(`${updated.length} updated, ${installed.length - outdated.length} already current.`);
 }

package/dist/index.js

@@ -1,98 +1,130 @@
 #!/usr/bin/env node
-import { searchCommand } from './commands/search.js';
-import { installCommand } from './commands/install.js';
-import { listCommand } from './commands/list.js';
-import { removeCommand } from './commands/remove.js';
-import { feedbackCommand } from './commands/feedback.js';
-import { updateCommand } from './commands/update.js';
-import { setupCommand } from './commands/setup.js';
-const VERSION = '1.0.8';
-const HELP = `ags v${VERSION} — search, install, and manage AI agent skills
-
-Usage:
-  ags search <query> [--json] [--limit N] [--platform NAME]
-  ags install <slug>  [--json] [--platform NAME]
-  ags setup                                        # Install all official skills
-  ags list            [--json]
-  ags remove <slug>
-  ags feedback <slug> <1-5> [comment]
-  ags update
-  ags --version
-  ags --help
-
-Commands:
-  search    Search for skills on agentskill.sh
-  install   Install a skill to your project
-  setup     Install all official agentskill.sh skills (/learn, /review-skill)
-  list      Show installed skills
-  remove    Uninstall a skill
-  feedback  Rate a skill (1-5) with optional comment
-  update    Check for and apply skill updates
-
-Examples:
-  ags setup
-  ags search react
-  ags install seo-optimizer
-  ags install @anthropics/react-best-practices
-  ags list --json
-  ags remove seo-optimizer
-  ags feedback seo-optimizer 5 "Worked perfectly"
-  ags update
-
-More info: https://agentskill.sh/install
-`;
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import pc from 'picocolors';
+import { showLogo, ORANGE, DIM } from './ui.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+const VERSION = pkg.version;
+const CMD = 'npx @agentskill.sh/cli';
+function printHelp() {
+    showLogo();
+    console.log(`  ${DIM('The package manager for AI agent skills')}  ${DIM('v' + VERSION)}`);
+    console.log();
+    console.log(`  ${pc.bold('Usage:')}`);
+    console.log(`    ${DIM('$')} ${CMD} ${ORANGE('<command>')} ${DIM('[options]')}`);
+    console.log();
+    console.log(`  ${pc.bold('Commands:')}`);
+    console.log(`    ${ORANGE('search')}   ${DIM('s')}      Search for skills on agentskill.sh`);
+    console.log(`    ${ORANGE('install')}  ${DIM('i')}      Install a skill to your project`);
+    console.log(`    ${ORANGE('setup')}             Install all official agentskill.sh skills`);
+    console.log(`    ${ORANGE('find')}     ${DIM('f')}      Browse and discover skills interactively`);
+    console.log(`    ${ORANGE('init')}              Scaffold a new SKILL.md`);
+    console.log(`    ${ORANGE('list')}     ${DIM('ls')}     Show installed skills`);
+    console.log(`    ${ORANGE('remove')}   ${DIM('rm')}     Uninstall a skill`);
+    console.log(`    ${ORANGE('feedback')} ${DIM('rate')}   Rate a skill (1-5) with optional comment`);
+    console.log(`    ${ORANGE('update')}            Update installed skills to latest versions`);
+    console.log();
+    console.log(`  ${pc.bold('Examples:')}`);
+    console.log(`    ${DIM('$')} ${CMD} setup`);
+    console.log(`    ${DIM('$')} ${CMD} search react`);
+    console.log(`    ${DIM('$')} ${CMD} install seo-optimizer`);
+    console.log(`    ${DIM('$')} ${CMD} install @anthropics/react-best-practices`);
+    console.log(`    ${DIM('$')} ${CMD} list`);
+    console.log(`    ${DIM('$')} ${CMD} feedback seo-optimizer 5 "Worked perfectly"`);
+    console.log();
+    console.log(`  ${DIM('More info:')} ${pc.underline('https://agentskill.sh/install')}`);
+    console.log();
+}
 async function main() {
     const args = process.argv.slice(2);
-    if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
-        console.log(HELP);
+    // No args: show full banner with commands
+    if (args.length === 0) {
+        printHelp();
+        return;
+    }
+    // Flags that bypass command routing
+    if (args.includes('--help') || args.includes('-h')) {
+        printHelp();
         return;
     }
     if (args.includes('--version') || args.includes('-v')) {
         console.log(VERSION);
         return;
     }
+    // Show logo on interactive commands (skip for --json)
+    if (!args.includes('--json')) {
+        showLogo();
+    }
     const command = args[0];
     const commandArgs = args.slice(1);
     try {
         switch (command) {
             case 'search':
-            case 's':
+            case 's': {
+                const { searchCommand } = await import('./commands/search.js');
                 await searchCommand(commandArgs);
                 break;
+            }
             case 'install':
-            case 'i':
+            case 'i': {
+                const { installCommand } = await import('./commands/install.js');
                 await installCommand(commandArgs);
                 break;
+            }
+            case 'setup': {
+                const { setupCommand } = await import('./commands/setup.js');
+                await setupCommand(commandArgs);
+                break;
+            }
+            case 'init': {
+                const { initCommand } = await import('./commands/init.js');
+                await initCommand(commandArgs);
+                break;
+            }
+            case 'find':
+            case 'f': {
+                const { findCommand } = await import('./commands/find.js');
+                await findCommand(commandArgs);
+                break;
+            }
             case 'list':
-            case 'ls':
+            case 'ls': {
+                const { listCommand } = await import('./commands/list.js');
                 await listCommand(commandArgs);
                 break;
+            }
             case 'remove':
-            case 'rm':
-            case 'uninstall':
+            case 'rm': {
+                const { removeCommand } = await import('./commands/remove.js');
                 await removeCommand(commandArgs);
                 break;
+            }
             case 'feedback':
-            case 'rate':
+            case 'rate': {
+                const { feedbackCommand } = await import('./commands/feedback.js');
                 await feedbackCommand(commandArgs);
                 break;
-            case 'update':
-            case 'upgrade':
+            }
+            case 'update': {
+                const { updateCommand } = await import('./commands/update.js');
                 await updateCommand(commandArgs);
                 break;
-            case 'setup':
-            case 'init':
-                await setupCommand(commandArgs);
-                break;
+            }
             default:
-                console.error(`Unknown command: ${command}`);
-                console.error('Run "ags --help" for usage.');
+                console.log(`  ${pc.red('Unknown command:')} ${command}`);
+                console.log();
+                console.log(`  Run ${DIM(`${CMD} --help`)} for usage.`);
+                console.log();
                 process.exit(1);
         }
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        console.error(`Error: ${message}`);
+        console.log();
+        console.log(`  ${pc.red('Error:')} ${message}`);
+        console.log();
         process.exit(1);
     }
 }

package/dist/installer.d.ts

@@ -0,0 +1,33 @@
+import type { AgentType, InstallResponse, InstallMode } from './types.js';
+export interface InstallOptions {
+    global?: boolean;
+    mode?: InstallMode;
+}
+export interface InstallResult {
+    agent: string;
+    dir: string;
+    files: string[];
+    success: boolean;
+    error?: string;
+}
+/**
+ * Sanitize a skill name into a filesystem-safe slug.
+ * Strips @owner/ prefix, lowercases, replaces non-alphanumeric with hyphens.
+ */
+export declare function sanitizeName(name: string): string;
+/**
+ * Install a skill to a single agent directory.
+ * Returns the path where the skill was installed.
+ */
+export declare function installSkillToAgent(skillData: InstallResponse, agentType: AgentType, options?: InstallOptions): InstallResult;
+/**
+ * Install a skill to multiple agents.
+ *
+ * Strategy:
+ *   1. First agent gets the canonical (full) copy of all files.
+ *   2. Remaining agents get a directory symlink pointing to the canonical copy.
+ *   3. If symlink creation fails (permissions, cross-device, Windows), falls back to a full copy.
+ *
+ * Set options.mode = 'copy' to skip symlinks entirely.
+ */
+export declare function installToAgents(skillData: InstallResponse, agentTypes: AgentType[], options?: InstallOptions): InstallResult[];