agentskillsdk 0.5.3 → 0.6.0

package/bin/cli.js

@@ -1,2 +1,50 @@
 #!/usr/bin/env node
-import '../src/index.js';
+import { run } from '../src/index.js';
+import { exitCodeFor, EXIT, AmbiguousError, NoAgentError, CanceledError } from '../src/lib/errors.js';
+import { setLocale, resolveLocale } from '../src/lib/messages/index.js';
+
+// Pre-parse --lang so help text and error messages emit in the requested
+// language even before commander runs.
+function scanLangFlag(argv) {
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === '--lang' && argv[i + 1]) return argv[i + 1];
+    if (argv[i].startsWith('--lang=')) return argv[i].slice(7);
+  }
+  return undefined;
+}
+function scanJsonFlag(argv) {
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === '--json') return true;
+  }
+  return false;
+}
+setLocale(resolveLocale({ flag: scanLangFlag(process.argv), env: process.env }));
+
+function emitJsonError(err) {
+  if (err instanceof CanceledError) {
+    return JSON.stringify({ error: 'canceled' });
+  }
+  if (err instanceof NoAgentError) {
+    return JSON.stringify({ error: 'no_agent_target', candidates: err.candidates || [] });
+  }
+  if (err instanceof AmbiguousError) {
+    return JSON.stringify({ error: 'ambiguous_agent', candidates: err.candidates || [] });
+  }
+  return JSON.stringify({ error: err && err.message ? err.message : String(err) });
+}
+
+try {
+  const code = await run();
+  process.exit(code ?? EXIT.OK);
+} catch (err) {
+  const code = exitCodeFor(err);
+  if (!err?.silent) {
+    if (scanJsonFlag(process.argv)) {
+      process.stderr.write(emitJsonError(err) + '\n');
+    } else {
+      const message = err && err.message ? err.message : String(err);
+      process.stderr.write(`${message}\n`);
+    }
+  }
+  process.exit(code);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentskillsdk",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Install agent skills from agentskills.dk",
   "type": "module",
   "bin": {
@@ -31,5 +31,8 @@
     "type": "git",
     "url": "https://github.com/agentskillsdk/cli"
   },
-  "homepage": "https://agentskills.dk"
+  "homepage": "https://agentskills.dk",
+  "scripts": {
+    "test": "node --test 'test/**/*.test.js'"
+  }
 }

package/src/commands/add.js

@@ -1,233 +1,339 @@
 import chalk from 'chalk';
-import ora from 'ora';
-import { symlinkSync, mkdirSync } from 'node:fs';
-import { join, relative, dirname } from 'node:path';
-import { homedir } from 'node:os';
+import { existsSync, readdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
 import { fetchSkill, fetchSkills } from '../lib/api.js';
-import { detectAgents, AGENTS, getUniversalAgents, getNonUniversalAgents } from '../lib/detect-agent.js';
+import { detectAgents, AGENTS, AGENT_BY_SLUG } from '../lib/detect-agent.js';
 import { downloadSkill } from '../lib/download.js';
-import { parseGithubSource } from '../lib/parse-source.js';
+import { resolveGithubSkillPath } from '../lib/resolve-github-path.js';
+import { parseSource } from '../lib/parse-source.js';
 import { selectPrompt, checkboxPrompt } from '../lib/prompt.js';
-import { printBanner, printInstallPlan, printCompletionSummary, step, error } from '../lib/ui.js';
+import { createOutput } from '../lib/output.js';
+import { detectRuntime } from '../lib/detect-runtime.js';
+import { t, setLocale } from '../lib/messages/index.js';
+import { UsageError, AmbiguousError, NoMatchError, FsError, NoAgentError, CanceledError } from '../lib/errors.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('kan ikke bruge både --global og --project. vælg én.');
-    process.exit(1);
+function isNonEmptyDir(p) {
+  try {
+    return readdirSync(p).length > 0;
+  } catch {
+    return false;
   }
+}
 
-  // --- resolve skill ---
-  let skill;
-  let installName;
+// When running inside an agent, hard-coding non-interactive defaults removes
+// every prompt before it can be reached. The only opt-out is an explicit
+// flag the caller has set (truthy `??` skip).
+function forceAgentDefaults(options, runtime) {
+  if (!runtime.isAgent) return options;
+  options.yes = true;
+  options.quiet ??= true;
+  options.lang ??= 'en';
+  if (runtime.agentSlug && (!options.agent || options.agent.length === 0)) {
+    options.agent = [runtime.agentSlug];
+  }
+  return options;
+}
 
-  if (isGithub) {
-    const skillPath = options.skill || '';
-    installName = skillPath ? skillPath.split('/').pop() : githubSource.repo;
-    skill = {
-      name: installName,
-      githubOwner: githubSource.owner,
-      githubRepo: githubSource.repo,
-      githubPath: skillPath,
-      defaultBranch: 'main',
-    };
-    step(`GitHub source: ${chalk.bold(`${githubSource.owner}/${githubSource.repo}`)}` +
-      (options.skill ? ` (skill: ${chalk.bold(options.skill)})` : ''));
-  } else {
-    installName = skillName;
-    const spinner = ora({ text: `søger efter ${chalk.bold(skillName)}...`, indent: 2 }).start();
-    try {
-      skill = await fetchSkill(skillName);
-    } catch (err) {
-      spinner.fail('opslag i registret fejlede');
-      error(err.message);
-      process.exit(1);
+function expandAgentSlugs(slugs) {
+  if (!slugs || slugs.length === 0) return [];
+  const out = [];
+  for (const s of slugs) {
+    if (s === '*') {
+      for (const a of AGENTS) out.push(a.slug);
+    } else {
+      out.push(s);
     }
+  }
+  // Dedupe in case '*' is mixed with explicit slugs.
+  return [...new Set(out)];
+}
 
-    if (!skill) {
-      spinner.fail(`skill "${skillName}" ikke fundet`);
-
-      let suggestions = [];
-      try {
-        const allSkills = await fetchSkills();
-        suggestions = allSkills
-          .filter(s => s.name.includes(skillName) || skillName.includes(s.name))
-          .slice(0, 3);
-      } catch {
-        // ignore
-      }
-
-      if (suggestions.length > 0) {
-        console.error('\n  mente du:');
-        suggestions.forEach(s => console.error(`    - ${chalk.bold(s.name)}`));
-      }
-      console.error(`\n  se alle skills: ${chalk.underline('https://agentskills.dk/skills')}\n`);
-      process.exit(1);
+export function chooseAgents(detected, options) {
+  if (options.agent && options.agent.length > 0) {
+    const slugs = expandAgentSlugs(options.agent);
+    const records = [];
+    for (const slug of slugs) {
+      const a = AGENT_BY_SLUG[slug];
+      if (!a) throw new UsageError(t('error.unknown_agent_slug', { slug }));
+      records.push(a);
     }
-
-    spinner.succeed(`fundet skill: ${chalk.bold(skill.name)}`);
+    return records;
   }
+  if (options.yes) {
+    if (detected.length === 1) return detected;
+    if (detected.length > 1) {
+      const cs = detected.map(a => a.slug).join(', ');
+      throw new AmbiguousError(t('error.ambiguous_agent', { candidates: cs }), {
+        candidates: detected.map(a => a.slug),
+      });
+    }
+    const cs = AGENTS.map(a => a.slug).join(', ');
+    throw new NoAgentError(t('error.no_agent_target', { candidates: cs }), {
+      candidates: AGENTS.map(a => a.slug),
+    });
+  }
+  return null; // signals interactive flow
+}
 
-  // --- agent selection + scope + confirmation (with back navigation) ---
-  const detected = detectAgents(cwd);
-  let agents;
-  let scope;
-
-  agentSelection: while (true) {
-    agents = null;
+export function chooseScope(options) {
+  if (options.global) return 'global';
+  if (options.project) return 'project';
+  if (options.yes) return 'project';
+  return null; // signals interactive flow
+}
 
+async function chooseAgentsInteractive(detected, out) {
+  while (true) {
+    let agents = null;
     if (detected.length === 1) {
-      // Auto-select the single detected agent
       agents = detected;
     } else if (detected.length > 1) {
-      // Prompt: all detected vs choose specific
-      const choice = await selectPrompt(chalk.bold('hvordan vil du installere?'), [
-        { label: `alle fundne agenter (${detected.length})`, value: 'all' },
-        { label: 'vælg specifikke agenter', value: 'choose' },
+      const choice = await selectPrompt(chalk.bold(t('add.prompt.how_install')), [
+        { label: t('add.prompt.all_detected', { count: detected.length }), value: 'all' },
+        { label: t('add.prompt.choose_specific'), value: 'choose' },
       ]);
-
-      if (choice === null) {
-        // Esc from top-level → cancel
-        process.exit(0);
-      }
-
+      if (choice === null) throw new CanceledError(t('error.canceled'));
       if (choice === 'all') {
         agents = detected;
       } else {
-        // Checkbox from detected agents
         const choices = detected.map(a => ({ label: a.name, value: a }));
-        const selected = await checkboxPrompt(chalk.bold('vælg agenter:'), choices);
-        if (selected === null) continue agentSelection; // Esc → back to all/choose
+        const selected = await checkboxPrompt(chalk.bold(t('add.prompt.select_agents')), choices);
+        if (selected === null) continue;
         agents = selected;
       }
     } else {
-      // No agents detected — show checkbox of all known agents
       const choices = AGENTS.map(a => ({ label: a.name, value: a }));
-      const selected = await checkboxPrompt(chalk.bold('vælg agenter:'), choices);
-      if (selected === null) {
-        // Esc with no detected agents → cancel
-        process.exit(0);
-      }
+      const selected = await checkboxPrompt(chalk.bold(t('add.prompt.select_agents')), choices);
+      if (selected === null) throw new CanceledError(t('error.canceled'));
       agents = selected;
     }
+    return agents;
+  }
+}
 
-    // --- resolve scope ---
-    if (options.global) {
-      scope = 'global';
-    } else if (options.project) {
-      scope = 'project';
-    } else {
-      const result = await selectPrompt(chalk.bold(`hvor skal "${installName}" installeres?`), [
-        { label: 'projekt', hint: '(lokalt .agents/skills/)', value: 'project' },
-        { label: 'globalt', hint: '(~/.agents/skills/)', value: 'global' },
-      ]);
+async function chooseScopeInteractive(installName, agents, detected) {
+  const a = agents[0];
+  const result = await selectPrompt(chalk.bold(t('add.prompt.scope', { name: installName })), [
+    { label: t('add.prompt.scope_project'), hint: t('add.prompt.scope_project_hint', { folder: a.folder }), value: 'project' },
+    { label: t('add.prompt.scope_global'), hint: t('add.prompt.scope_global_hint', { folder: a.globalFolder }), value: 'global' },
+  ]);
+  if (result === null) {
+    // Walk back to agent selection if it was a real choice.
+    if (detected.length === 1) throw new CanceledError(t('error.canceled'));
+    return null;
+  }
+  return result;
+}
+
+function announceAgentFolderCreation(agents, cwd, scope, out) {
+  if (scope !== 'project') return;
+  for (const a of agents) {
+    if (!existsSync(join(cwd, a.folder))) {
+      out.step(t('agent.folder_created', { folder: `${a.folder}/`, name: a.name }));
+    }
+  }
+}
 
-      if (result === null) {
-        // Esc → back to agent selection (unless auto-selected single agent)
-        if (detected.length === 1) process.exit(0);
-        continue agentSelection;
+function validateOptions(options) {
+  if (options.global && options.project) {
+    throw new UsageError(t('add.error.both_flags'));
+  }
+  if (options.agent && options.agent.length > 0) {
+    for (const slug of expandAgentSlugs(options.agent)) {
+      if (!AGENT_BY_SLUG[slug]) {
+        throw new UsageError(t('error.unknown_agent_slug', { slug }));
       }
-      scope = result;
     }
+  }
+}
 
-    // --- confirmation screen ---
-    const universalAgents = getUniversalAgents(agents);
-    const nonUniversalAgents = getNonUniversalAgents(agents);
+export async function addCommand(skillName, options = {}) {
+  const runtime = detectRuntime();
+  forceAgentDefaults(options, runtime);
+  if (options.lang) setLocale(options.lang);
 
-    const source = isGithub
-      ? `${skill.githubOwner}/${skill.githubRepo}`
-      : (skill.namespace || skill.name);
+  validateOptions(options);
 
-    printInstallPlan({
-      skillName: installName,
-      source,
-      scope,
-      universalAgents,
-      symlinkAgents: nonUniversalAgents,
-    });
+  const out = createOutput(options, runtime);
+  out.banner();
+
+  const cwd = process.cwd();
+  const parsed = parseSource(skillName);
+  const isGithub = parsed.kind === 'github';
 
-    const confirm = await selectPrompt(chalk.bold('fortsæt med installation?'), [
-      { label: 'ja, installer', value: 'yes' },
-      { label: 'nej, annullér', value: 'no' },
-    ]);
+  let skill;
+  let installName;
 
-    if (confirm === null || confirm === 'no') {
-      // Esc or "nej" → back to scope selection (or exit if flags were set)
-      if (options.global || options.project) process.exit(0);
-      continue agentSelection;
+  if (isGithub) {
+    // `--skill` flag wins over any parsed skill/path token.
+    const parsedPath = parsed.path || parsed.skill || '';
+    const requestedPath = options.skill || parsedPath;
+
+    const hasRef = !!parsed.ref;
+    const hasSkill = !!requestedPath;
+    let msgKey;
+    if (hasRef && hasSkill) msgKey = 'add.source.github_with_ref_and_skill';
+    else if (hasRef) msgKey = 'add.source.github_with_ref';
+    else if (hasSkill) msgKey = 'add.source.github_with_skill';
+    else msgKey = 'add.source.github';
+    out.step(t(msgKey, { owner: parsed.owner, repo: parsed.repo, ref: parsed.ref, skill: requestedPath }));
+
+    // Resolve the requested path against the actual repo layout. The website's
+    // registry runs `matchSkillToPath` during indexing for the same reason —
+    // users type `--skill foo` but the file lives at `skills/foo/SKILL.md`.
+    //
+    // Only resolve when the caller asked for a specific skill — for bare
+    // `owner/repo` we preserve the existing "install whatever's in the tarball"
+    // behavior so registry-style installs and single-skill repos still work.
+    let skillPath = requestedPath;
+    if (requestedPath) {
+      const lookup = out.spinner(t('add.spinner.resolving_path'));
+      let resolved;
+      try {
+        resolved = await resolveGithubSkillPath({
+          owner: parsed.owner,
+          repo: parsed.repo,
+          ref: parsed.ref,
+          requestedPath,
+        });
+      } catch (err) {
+        lookup.fail(t('add.error.resolve_fail'));
+        throw err;
+      }
+      if (resolved.resolved) {
+        lookup.succeed(t('add.spinner.resolved_path', { from: requestedPath, to: resolved.path }));
+      } else {
+        lookup.succeed(t('add.spinner.path_ok'));
+      }
+      skillPath = resolved.path;
+    }
+    installName = skillPath ? skillPath.split('/').pop() : parsed.repo;
+    skill = {
+      name: installName,
+      githubOwner: parsed.owner,
+      githubRepo: parsed.repo,
+      githubPath: skillPath || undefined,
+      ref: parsed.ref,
+    };
+  } else {
+    installName = parsed.name;
+    const spinner = out.spinner(t('add.spinner.lookup', { name: chalk.bold(parsed.name) }));
+    try {
+      skill = await fetchSkill(parsed.name);
+    } catch (err) {
+      spinner.fail(t('add.error.registry_fail'));
+      throw err;
     }
 
-    break; // selection + confirmation complete
+    if (!skill) {
+      spinner.fail(t('add.error.not_found', { name: parsed.name }));
+      if (!out.isJson && !out.isQuiet) {
+        let suggestions = [];
+        try {
+          const allSkills = await fetchSkills();
+          suggestions = allSkills
+            .filter(s => s.name.includes(parsed.name) || parsed.name.includes(s.name))
+            .slice(0, 3);
+        } catch { /* ignore */ }
+        if (suggestions.length > 0) {
+          process.stderr.write(`\n  ${t('add.suggest.header')}\n`);
+          for (const s of suggestions) {
+            process.stderr.write(`    - ${chalk.bold(s.name)}\n`);
+          }
+        }
+        process.stderr.write(`\n  ${t('add.suggest.browse')} ${chalk.underline('https://agentskills.dk/skills')}\n\n`);
+      }
+      throw new NoMatchError(t('add.error.not_found', { name: parsed.name }));
+    }
+    spinner.succeed(t('add.spinner.found', { name: chalk.bold(skill.name) }));
   }
 
-  // --- step message ---
-  if (agents.length === 1) {
-    step(`Agent: ${chalk.bold(agents[0].name)}`);
-  } else {
-    step(`Agents: ${chalk.bold(agents.map(a => a.name).join(', '))}`);
-  }
+  const detected = detectAgents(cwd);
 
-  // --- download to canonical .agents/skills/ then symlink ---
-  const spinner = ora({ text: 'downloader skill-filer...', indent: 2 }).start();
+  let agents = chooseAgents(detected, options);
+  let scope = chooseScope(options);
 
-  const symlinkResults = { canonical: [], symlinked: [], copied: [] };
+  // Interactive fallback when --yes / --agent aren't supplied.
+  if (agents === null || scope === null) {
+    while (true) {
+      if (agents === null) agents = await chooseAgentsInteractive(detected, out);
+      if (scope === null) {
+        scope = await chooseScopeInteractive(installName, agents, detected);
+        if (scope === null) { agents = null; continue; }
+      }
+      break;
+    }
+  }
 
-  try {
-    // Canonical location: always .agents/skills/<name>/
-    const base = scope === 'global' ? homedir() : cwd;
-    const canonicalDir = join(base, '.agents', 'skills', installName);
+  announceAgentFolderCreation(agents, cwd, scope, out);
 
-    // Download once to canonical
-    await downloadSkill(skill, canonicalDir);
+  if (agents.length === 1) {
+    out.step(t('add.step.agent_single', { name: chalk.bold(agents[0].name) }));
+  } else {
+    out.step(t('add.step.agent_multi', { names: chalk.bold(agents.map(a => a.name).join(', ')) }));
+  }
 
-    // Track which agents got the canonical copy (universal agents using .agents/)
-    const universalAgents = getUniversalAgents(agents);
-    const nonUniversalAgents = getNonUniversalAgents(agents);
+  // Compute destination dirs once — used by both dry-run preview and the
+  // pre-download dest-exists check.
+  const destPlan = agents.map(agent => ({
+    agent,
+    destDir: agent.path(installName, { cwd, scope }),
+  }));
 
-    for (const a of universalAgents) {
-      symlinkResults.canonical.push(a);
-    }
+  const sourcePayload = isGithub
+    ? { type: 'github', owner: parsed.owner, repo: parsed.repo, ref: parsed.ref, path: skill.githubPath || undefined }
+    : { type: 'registry', namespace: skill.namespace };
 
-    // For each non-universal agent, symlink from their path → canonical
-    for (const agent of nonUniversalAgents) {
-      const agentDir = agent.path(installName, { cwd, scope });
+  if (options.dryRun) {
+    out.dryRun({
+      skill: installName,
+      scope,
+      source: sourcePayload,
+      agents: destPlan.map(({ agent, destDir }) => ({
+        slug: agent.slug,
+        name: agent.name,
+        path: destDir,
+      })),
+    });
+    return;
+  }
 
-      if (agentDir === canonicalDir) {
-        symlinkResults.canonical.push(agent);
-        continue;
+  // --force / dest-exists guard. Runs before any network I/O so we don't
+  // download bytes only to refuse to write them.
+  for (const { destDir } of destPlan) {
+    if (existsSync(destDir) && isNonEmptyDir(destDir)) {
+      if (!options.force) {
+        throw new FsError(t('add.error.dest_exists', { path: destDir }));
       }
+      out.step(t('add.step.removing_existing', { path: destDir }));
+      rmSync(destDir, { recursive: true, force: true });
+    }
+  }
 
-      mkdirSync(dirname(agentDir), { recursive: true });
-      try {
-        const rel = relative(dirname(agentDir), canonicalDir);
-        symlinkSync(rel, agentDir);
-        symlinkResults.symlinked.push(agent);
-      } catch {
-        // Fallback: download again
-        await downloadSkill(skill, agentDir);
-        symlinkResults.copied.push(agent);
-      }
+  const spinner = out.spinner(t('add.spinner.downloading'));
+  try {
+    for (const { destDir } of destPlan) {
+      await downloadSkill(skill, destDir);
     }
   } catch (err) {
-    spinner.fail('download fejlede');
-    error(err.message);
-    process.exit(1);
+    spinner.fail(t('add.error.download_fail'));
+    throw err;
   }
-  spinner.succeed('skill-filer downloadet');
+  spinner.succeed(t('add.spinner.downloaded'));
+
+  const agentsWithPath = agents.map(a => ({
+    slug: a.slug,
+    name: a.name,
+    path: a.displayPath(installName, scope),
+    displayPath: a.displayPath,
+  }));
 
-  // --- completion summary ---
-  printCompletionSummary({
-    skillName: installName,
+  out.success({
+    skill: installName,
     scope,
-    agents,
+    agents: agentsWithPath,
     isGithub,
     namespace: skill.namespace,
-    symlinkResults,
+    source: sourcePayload,
   });
 }

package/src/commands/list.js

@@ -1,30 +1,32 @@
 import chalk from 'chalk';
 import { fetchSkills } from '../lib/api.js';
-import { printBanner } from '../lib/ui.js';
+import { createOutput } from '../lib/output.js';
+import { detectRuntime } from '../lib/detect-runtime.js';
+import { t } from '../lib/messages/index.js';
 
-export async function listCommand() {
-  printBanner();
-  let skills;
-  try {
-    skills = await fetchSkills();
-  } catch (err) {
-    console.error(chalk.red(`\n  ${err.message}\n`));
-    process.exit(1);
+export async function listCommand(options = {}) {
+  const runtime = detectRuntime();
+  const out = createOutput(options, runtime);
+  out.banner();
+
+  const skills = await fetchSkills();
+
+  if (out.isJson) {
+    out.json({ skills });
+    return;
   }
 
   if (skills.length === 0) {
-    console.log('\n  ingen skills tilgængelige endnu.\n');
+    process.stdout.write(`\n  ${t('list.empty')}\n\n`);
     return;
   }
 
-  console.log(chalk.bold('\n  tilgængelige skills:\n'));
-
+  process.stdout.write(chalk.bold(`\n  ${t('list.header')}\n\n`));
   const maxName = Math.max(...skills.map(s => s.name.length));
-
   for (const skill of skills) {
-    console.log(`  ${chalk.cyan(skill.name.padEnd(maxName + 2))} ${skill.description}`);
+    process.stdout.write(`  ${chalk.cyan(skill.name.padEnd(maxName + 2))} ${skill.description}\n`);
   }
 
-  console.log(`\n  installer: ${chalk.bold('npx agentskillsdk add <skill-name>')}`);
-  console.log(`  gennemse:  ${chalk.underline('https://agentskills.dk/skills')}\n`);
+  process.stdout.write(`\n  ${t('list.install')} ${chalk.bold('npx agentskillsdk add <skill-name>')}\n`);
+  process.stdout.write(`  ${t('list.browse')}  ${chalk.underline('https://agentskills.dk/skills')}\n\n`);
 }