agentskillsdk 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentskillsdk",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Install agent skills from agentskills.dk",
   "type": "module",
   "bin": {
@@ -13,6 +13,7 @@
   "dependencies": {
     "commander": "^13.0.0",
     "chalk": "^5.4.0",
+    "ora": "^8.1.0",
     "tar-stream": "^3.1.0"
   },
   "engines": {

package/src/commands/add.js

@@ -1,19 +1,30 @@
 import chalk from 'chalk';
-import { join } from 'node:path';
+import ora from 'ora';
 import { fetchSkill, fetchSkills } from '../lib/api.js';
 import { detectAgents } from '../lib/detect-agent.js';
 import { downloadSkill } from '../lib/download.js';
 import { parseGithubSource } from '../lib/parse-source.js';
+import { selectPrompt } from '../lib/prompt.js';
+import { printBanner, printCompletionSummary, step, error } from '../lib/ui.js';
 
 export async function addCommand(skillName, options) {
+  printBanner();
+
   const cwd = process.cwd();
   const githubSource = parseGithubSource(skillName);
+  const isGithub = !!githubSource;
+
+  // --- resolve scope flags ---
+  if (options.global && options.project) {
+    error('Cannot use both --global and --project. Pick one.');
+    process.exit(1);
+  }
 
+  // --- resolve skill ---
   let skill;
   let installName;
 
-  if (githubSource) {
-    // GitHub owner/repo source
+  if (isGithub) {
     const skillPath = options.skill || '';
     installName = skillPath ? skillPath.split('/').pop() : githubSource.repo;
     skill = {
@@ -23,19 +34,22 @@ export async function addCommand(skillName, options) {
       githubPath: skillPath,
       defaultBranch: 'main',
     };
-    console.log(chalk.green('  \u2713') + ` GitHub source: ${chalk.bold(`${githubSource.owner}/${githubSource.repo}`)}` +
+    step(`GitHub source: ${chalk.bold(`${githubSource.owner}/${githubSource.repo}`)}` +
       (options.skill ? ` (skill: ${chalk.bold(options.skill)})` : ''));
   } else {
-    // Registry source
     installName = skillName;
+    const spinner = ora({ text: `Looking up ${chalk.bold(skillName)}...`, indent: 2 }).start();
     try {
       skill = await fetchSkill(skillName);
     } catch (err) {
-      console.error(chalk.red(`\n  ${err.message}\n`));
+      spinner.fail('Registry lookup failed');
+      error(err.message);
       process.exit(1);
     }
 
     if (!skill) {
+      spinner.fail(`Skill "${skillName}" not found`);
+
       let suggestions = [];
       try {
         const allSkills = await fetchSkills();
@@ -43,44 +57,58 @@ export async function addCommand(skillName, options) {
           .filter(s => s.name.includes(skillName) || skillName.includes(s.name))
           .slice(0, 3);
       } catch {
-        // If we can't fetch suggestions, just show the not-found message
+        // ignore
       }
 
-      console.error(chalk.red(`\n  Skill "${skillName}" not found.\n`));
       if (suggestions.length > 0) {
-        console.error('  Did you mean:');
+        console.error('\n  Did you mean:');
         suggestions.forEach(s => console.error(`    - ${chalk.bold(s.name)}`));
-        console.error('');
       }
-      console.error(`  Browse all skills: ${chalk.underline('https://agentskills.dk/skills')}\n`);
+      console.error(`\n  Browse all skills: ${chalk.underline('https://agentskills.dk/skills')}\n`);
       process.exit(1);
     }
 
-    console.log(chalk.green('  \u2713') + ` Found skill: ${chalk.bold(skill.name)}`);
+    spinner.stop();
+    step(`Found skill: ${chalk.bold(skill.name)}`);
   }
 
-  // 2. Detect agent
+  // --- detect agent ---
   const agents = await detectAgents(cwd);
-  console.log(chalk.green('  \u2713') + ` Detected agent: ${chalk.bold(agents[0].name)}`);
+  const agent = agents[0];
+  step(`Detected agent: ${chalk.bold(agent.name)}`);
 
-  // 3. Download + install for each selected agent
-  for (const agent of agents) {
-    const destDir = join(cwd, agent.path(installName));
-    try {
-      await downloadSkill(skill, destDir);
-    } catch (err) {
-      console.error(chalk.red(`\n  Failed to download skill files. Try again or report at agentskills.dk/support`));
-      console.error(chalk.red(`  ${err.message}\n`));
-      process.exit(1);
-    }
-    console.log(chalk.green('  \u2713') + ` Installed to ${agent.path(installName)}`);
+  // --- resolve scope ---
+  let scope;
+  if (options.global) {
+    scope = 'global';
+  } else if (options.project) {
+    scope = 'project';
+  } else {
+    scope = await selectPrompt('Install scope:', [
+      { label: 'Project', hint: '(.claude/skills/ in current directory)', value: 'project' },
+      { label: 'Global', hint: '(~/.claude/skills/ for all projects)', value: 'global' },
+    ]);
   }
 
-  // 4. Done
-  console.log(`\n  Skill ready. Start a new ${agents[0].name} session to use it.`);
-  if (!githubSource) {
-    console.log(`  Learn more: ${chalk.underline(`https://agentskills.dk/skills/${skill.namespace}`)}\n`);
-  } else {
-    console.log('');
+  // --- download ---
+  const destDir = agent.path(installName, { cwd, scope });
+  const spinner = ora({ text: 'Downloading skill files...', indent: 2 }).start();
+  try {
+    await downloadSkill(skill, destDir);
+  } catch (err) {
+    spinner.fail('Download failed');
+    error(err.message);
+    process.exit(1);
   }
+  spinner.succeed('Downloaded skill files');
+
+  // --- completion summary ---
+  printCompletionSummary({
+    skillName: installName,
+    scope,
+    installPath: agent.displayPath(installName, scope),
+    agentName: agent.name,
+    isGithub,
+    namespace: skill.namespace,
+  });
 }

package/src/commands/list.js

@@ -1,7 +1,9 @@
 import chalk from 'chalk';
 import { fetchSkills } from '../lib/api.js';
+import { printBanner } from '../lib/ui.js';
 
 export async function listCommand() {
+  printBanner();
   let skills;
   try {
     skills = await fetchSkills();

package/src/index.js

@@ -1,19 +1,25 @@
 import { Command } from 'commander';
+import { createRequire } from 'node:module';
 import { addCommand } from './commands/add.js';
 import { listCommand } from './commands/list.js';
 
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
 const program = new Command();
 
 program
   .name('agentskillsdk')
   .description('Install agent skills from agentskills.dk')
-  .version('0.1.0');
+  .version(pkg.version);
 
 program
   .command('add')
   .description('Install a skill into your project')
   .argument('<skill-name>', 'name of the skill to install (or owner/repo for GitHub)')
   .option('--skill <path>', 'path within repo, e.g. skills/twitter')
+  .option('-g, --global', 'install globally to ~/.claude/skills/')
+  .option('-p, --project', 'install to project .claude/skills/ (default)')
   .action(addCommand);
 
 program

package/src/lib/detect-agent.js

@@ -1,34 +1,35 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { createInterface } from 'node:readline';
+import { homedir } from 'node:os';
+import { selectPrompt } from './prompt.js';
 
 const AGENTS = [
-  { name: 'Claude Code', folder: '.claude', path: (skill) => `.claude/skills/${skill}/` },
+  {
+    name: 'Claude Code',
+    folder: '.claude',
+    path: (skill, { cwd, scope }) => {
+      if (scope === 'global') return join(homedir(), '.claude', 'skills', skill);
+      return join(cwd, '.claude', 'skills', skill);
+    },
+    displayPath: (skill, scope) => {
+      if (scope === 'global') return `~/.claude/skills/${skill}/`;
+      return `.claude/skills/${skill}/`;
+    },
+  },
 ];
 
 export async function detectAgents(cwd) {
   const found = AGENTS.filter(agent => existsSync(join(cwd, agent.folder)));
 
   if (found.length === 1) return [found[0]];
-  if (found.length > 1) return await promptUserChoice(found);
-  return await promptUserChoice(AGENTS);
-}
-
-async function promptUserChoice(agents) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-
-  console.log('\nWhich agent do you use?\n');
-  agents.forEach((a, i) => console.log(`  ${i + 1}) ${a.name}`));
+  if (found.length > 1) {
+    const choices = found.map(a => ({ label: a.name, value: a }));
+    const selected = await selectPrompt('Which agent do you use?', choices);
+    return [selected];
+  }
 
-  return new Promise((resolve) => {
-    rl.question('\nChoice: ', (answer) => {
-      rl.close();
-      const idx = parseInt(answer, 10) - 1;
-      if (idx >= 0 && idx < agents.length) {
-        resolve([agents[idx]]);
-      } else {
-        resolve([agents[0]]);
-      }
-    });
-  });
+  // None found — ask user to pick
+  const choices = AGENTS.map(a => ({ label: a.name, value: a }));
+  const selected = await selectPrompt('Which agent do you use?', choices);
+  return [selected];
 }

package/src/lib/prompt.js

@@ -0,0 +1,90 @@
+import chalk from 'chalk';
+
+/**
+ * Interactive select prompt with arrow-key navigation.
+ * Up/Down to move, Enter to confirm.
+ *
+ * @param {string} question
+ * @param {{ label: string, hint?: string, value: any }[]} choices
+ * @param {{ defaultIndex?: number }} opts
+ * @returns {Promise<any>} selected value
+ */
+export function selectPrompt(question, choices, { defaultIndex = 0 } = {}) {
+  return new Promise((resolve) => {
+    let selected = defaultIndex;
+    const { stdin, stdout } = process;
+
+    function render() {
+      // Move cursor up to overwrite previous render (all choice lines + 1 blank line below question)
+      // On first render we just printed the question, so we only clear choice lines after that
+      const lines = choices.map((c, i) => {
+        const marker = i === selected ? chalk.cyan('\u276f') : ' ';
+        const label = i === selected ? chalk.cyan(c.label) : c.label;
+        const hint = c.hint ? chalk.dim(` ${c.hint}`) : '';
+        return `    ${marker} ${label}${hint}`;
+      });
+      return lines.join('\n');
+    }
+
+    // Print question
+    stdout.write(`\n  ${question}\n\n`);
+
+    // Initial render
+    stdout.write(render());
+
+    // Enter raw mode for keypress detection
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+
+    function onData(buf) {
+      const key = buf.toString();
+
+      // Ctrl+C
+      if (key === '\x03') {
+        stdin.setRawMode(wasRaw ?? false);
+        stdin.removeListener('data', onData);
+        stdin.pause();
+        stdout.write('\n');
+        process.exit(0);
+      }
+
+      // Enter
+      if (key === '\r' || key === '\n') {
+        stdin.setRawMode(wasRaw ?? false);
+        stdin.removeListener('data', onData);
+        stdin.pause();
+        // Clear the choices and rewrite with final selection
+        stdout.write(`\x1b[${choices.length}A`); // move up
+        stdout.write('\x1b[J'); // clear to end
+        const final = choices.map((c, i) => {
+          if (i === selected) {
+            return `    ${chalk.cyan('\u276f')} ${chalk.cyan(c.label)}`;
+          }
+          return '';
+        }).filter(Boolean).join('\n');
+        stdout.write(final + '\n');
+        resolve(choices[selected].value);
+        return;
+      }
+
+      // Arrow keys come as escape sequences: \x1b[A (up), \x1b[B (down)
+      if (key === '\x1b[A' || key === '\x1b[D') {
+        // Up or Left
+        selected = (selected - 1 + choices.length) % choices.length;
+      } else if (key === '\x1b[B' || key === '\x1b[C') {
+        // Down or Right
+        selected = (selected + 1) % choices.length;
+      } else {
+        return; // ignore other keys
+      }
+
+      // Redraw: move cursor up N lines, clear, rewrite
+      stdout.write(`\x1b[${choices.length}A`);
+      stdout.write('\x1b[J');
+      stdout.write(render());
+    }
+
+    stdin.on('data', onData);
+  });
+}

package/src/lib/ui.js

@@ -0,0 +1,80 @@
+import chalk from 'chalk';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+
+// --- strip ANSI for width calculation ---
+
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(str) {
+  return str.replace(ANSI_RE, '');
+}
+
+// --- box drawing ---
+
+export function box(lines, { borderColor, padding = 2 } = {}) {
+  const maxWidth = Math.max(...lines.map(l => stripAnsi(l).length));
+  const pad = ' '.repeat(padding);
+  const inner = maxWidth + padding * 2;
+
+  const colorize = borderColor ? chalk[borderColor].bind(chalk) : (s) => s;
+
+  const top = colorize(`  \u250c${'─'.repeat(inner)}\u2510`);
+  const bottom = colorize(`  \u2514${'─'.repeat(inner)}\u2518`);
+  const rowLines = lines.map(l => {
+    const visible = stripAnsi(l).length;
+    const rightPad = ' '.repeat(maxWidth - visible);
+    return `  ${colorize('\u2502')}${pad}${l}${rightPad}${pad}${colorize('\u2502')}`;
+  });
+
+  return [top, ...rowLines, bottom].join('\n');
+}
+
+// --- banner ---
+
+export function printBanner() {
+  const lines = [
+    `${chalk.bold('agentskillsdk')}  ${chalk.dim(`v${pkg.version}`)}`,
+    chalk.dim('Install skills for AI agents'),
+  ];
+  console.log('');
+  console.log(box(lines));
+  console.log('');
+}
+
+// --- completion summary ---
+
+export function printCompletionSummary({ skillName, scope, installPath, agentName, isGithub, namespace }) {
+  const scopeLabel = scope === 'global'
+    ? 'Global (all projects)'
+    : 'Project (local)';
+
+  const lines = [
+    chalk.bold.green('Skill installed successfully!'),
+    '',
+    `  ${chalk.dim('Skill:')}   ${skillName}`,
+    `  ${chalk.dim('Scope:')}   ${scopeLabel}`,
+    `  ${chalk.dim('Path:')}    ${installPath}`,
+    '',
+    `Start a new ${agentName} session to use it.`,
+  ];
+
+  if (!isGithub && namespace) {
+    lines.push(`Learn more: ${chalk.underline(`https://agentskills.dk/skills/${namespace}`)}`);
+  }
+
+  console.log('');
+  console.log(box(lines, { borderColor: 'green' }));
+  console.log('');
+}
+
+// --- step / error output ---
+
+export function step(text) {
+  console.log(chalk.green('  \u2713') + ` ${text}`);
+}
+
+export function error(text) {
+  console.error(chalk.red(`  ${text}`));
+}