claude-agent-skills 1.3.0

package/commands/exportSkills.js

@@ -0,0 +1,30 @@
+import { note, outro } from '@clack/prompts';
+import { writeFileSync } from 'node:fs';
+import { showIntro } from '../lib/banner.js';
+import { readLock } from '../lib/lockfile.js';
+import { resolveScope } from '../lib/scope.js';
+import { pickScope } from '../lib/prompts.js';
+
+export async function runExport(opts = {}) {
+  await showIntro({ skip: opts.skipIntro ?? true });
+
+  const scopeFlags = await pickScope(opts);
+  const scope = resolveScope({ global: scopeFlags.global });
+  const lock = await readLock(scope.lockPath);
+
+  if (!lock || !Object.keys(lock.skills).length) {
+    note(`No skills installed at ${scope.lockPath}.`, 'Nothing to export');
+    outro('');
+    return;
+  }
+
+  const json = `${JSON.stringify(lock, null, 2)}\n`;
+
+  if (opts.file) {
+    writeFileSync(opts.file, json, 'utf8');
+    note(`Wrote ${Object.keys(lock.skills).length} skill(s) to ${opts.file}\nShare this file with teammates and have them run:\n  claude-agent-skills import --file ${opts.file}`, 'Exported');
+    outro('Done.');
+  } else {
+    process.stdout.write(json);
+  }
+}

package/commands/hub.js

@@ -0,0 +1,52 @@
+import { select, isCancel, cancel, outro } from '@clack/prompts';
+import updateNotifier from 'update-notifier';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { showIntro } from '../lib/banner.js';
+import { CliCancel } from '../lib/prompts.js';
+
+const req = createRequire(import.meta.url);
+const pkg = req(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'));
+updateNotifier({ pkg }).notify();
+import { runAdd } from './add.js';
+import { runUpdate } from './update.js';
+import { runRemove } from './remove.js';
+import { runList } from './list.js';
+import { runSync } from './sync.js';
+import { runCheck } from './check.js';
+
+const SKIP = { skipIntro: true };
+
+const MENU = [
+  { value: 'add',    label: 'Add Skill(s)' },
+  { value: 'update', label: 'Update Existing Skill(s)' },
+  { value: 'remove', label: 'Remove Existing Skill(s)' },
+  { value: 'list',   label: 'List Installed Skill(s)' },
+  { value: 'sync',   label: 'Sync/Restore Skills from Lockfile' },
+  { value: 'check',  label: 'Check Skill(s)' },
+  { value: 'quit',   label: 'Quit' },
+];
+
+export async function runHub() {
+  await showIntro();
+
+  for (;;) {
+    const choice = await select({ message: 'What do you want to do?', options: MENU });
+
+    if (isCancel(choice)) { cancel('Cancelled.'); return; }
+    if (choice === 'quit') { outro('Goodbye.'); return; }
+
+    try {
+      if (choice === 'add')    await runAdd(SKIP);
+      if (choice === 'update') await runUpdate(SKIP);
+      if (choice === 'remove') await runRemove(SKIP);
+      if (choice === 'list')   await runList(SKIP);
+      if (choice === 'sync')   await runSync(SKIP);
+      if (choice === 'check')  await runCheck(SKIP);
+    } catch (e) {
+      if (e instanceof CliCancel) continue;
+      throw e;
+    }
+  }
+}

package/commands/importSkills.js

@@ -0,0 +1,68 @@
+import { note, outro } from '@clack/prompts';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { showIntro } from '../lib/banner.js';
+import { readLock, writeLock, upsertSkill } from '../lib/lockfile.js';
+import { resolveScope, ensureDirs } from '../lib/scope.js';
+import { pickScope, confirmProceed } from '../lib/prompts.js';
+import { materialize } from '../lib/install.js';
+import { hashSkill } from '../lib/hash.js';
+
+const BUNDLE_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'bundled-skills');
+
+export async function runImport(opts = {}) {
+  await showIntro({ skip: opts.skipIntro ?? true });
+
+  const file = opts.file;
+  if (!file) {
+    console.error('Specify a file: claude-agent-skills import --file <lockfile.json>');
+    return;
+  }
+
+  let imported;
+  try {
+    imported = JSON.parse(readFileSync(file, 'utf8'));
+  } catch (e) {
+    console.error(`Could not read ${file}: ${e.message}`);
+    return;
+  }
+
+  const skills = Object.keys(imported.skills ?? {});
+  if (!skills.length) {
+    note('No skills found in the imported lockfile.', 'Empty');
+    outro('');
+    return;
+  }
+
+  const scopeFlags = await pickScope(opts);
+  const scope = resolveScope({ global: scopeFlags.global });
+
+  note(`${skills.length} skill(s) from ${file}:\n${skills.join(', ')}`, 'Ready to import');
+
+  const proceed = await confirmProceed(`Install ${skills.length} skill(s)?`);
+  if (!proceed) { outro('Cancelled. No changes made.'); return; }
+
+  await ensureDirs(scope);
+  const lock = (await readLock(scope.lockPath)) ?? { version: 1, skills: {} };
+  const installed = [], skipped = [];
+
+  for (const name of skills.sort()) {
+    const src = join(BUNDLE_DIR, name);
+    if (!existsSync(src)) { skipped.push(name); continue; }
+
+    const entry = imported.skills[name];
+    const copy = entry?.linkType !== 'symlink';
+    await materialize({ src, dest: join(scope.skillsDir, name), copy });
+    if (scope.agentsSkillsDir) {
+      await materialize({ src, dest: join(scope.agentsSkillsDir, name), copy });
+    }
+    upsertSkill(lock, name, { computedHash: await hashSkill(src), linkType: copy ? 'copy' : 'symlink' });
+    installed.push(name);
+  }
+
+  await writeLock(scope.lockPath, lock);
+
+  if (skipped.length) note(`Skipped (not in bundle): ${skipped.join(', ')}`, 'Warning');
+  outro(`Imported ${installed.length} skill(s). Restart Claude Code.`);
+}

package/commands/list.js

@@ -0,0 +1,37 @@
+import { note, outro } from '@clack/prompts';
+import { join } from 'node:path';
+import { showIntro } from '../lib/banner.js';
+import { readLock } from '../lib/lockfile.js';
+import { resolveScope } from '../lib/scope.js';
+import { pickScope } from '../lib/prompts.js';
+import { pathExists, isBroken } from '../lib/install.js';
+import { renderListSummary } from '../lib/summary.js';
+
+export async function runList(opts = {}) {
+  await showIntro({ skip: opts.skipIntro });
+
+  const scopeFlags = await pickScope(opts);
+  const scope = resolveScope({ global: scopeFlags.global });
+  const lock = await readLock(scope.lockPath);
+
+  if (!lock || !Object.keys(lock.skills).length) {
+    console.log(`No skills installed. Lockfile not found at: ${scope.lockPath}`);
+    outro('');
+    return;
+  }
+
+  const rows = await Promise.all(
+    Object.entries(lock.skills).sort().map(async ([name, entry]) => {
+      const dest = join(scope.skillsDir, name);
+      const ex = await pathExists(dest);
+      const broken = ex && await isBroken(dest);
+      const status = ex && !broken ? 'ok' : broken ? 'broken' : 'missing';
+      return { name, linkType: entry.linkType, hash: entry.computedHash.slice(0, 8), status, healthy: status === 'ok' };
+    }),
+  );
+
+  note(renderListSummary({
+    scope: scope.scope, skillsDir: scope.skillsDir, lockPath: scope.lockPath, rows,
+  }), 'Installed skills');
+  outro('');
+}

package/commands/remove.js

@@ -0,0 +1,59 @@
+import { multiselect, note, outro, isCancel } from '@clack/prompts';
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { showIntro } from '../lib/banner.js';
+import { readLock, writeLock, removeSkill } from '../lib/lockfile.js';
+import { resolveScope } from '../lib/scope.js';
+import { pickScope, confirmProceed, CliCancel } from '../lib/prompts.js';
+import { pathExists } from '../lib/install.js';
+import { renderRemoveSummary } from '../lib/summary.js';
+
+export async function runRemove(opts = {}) {
+  await showIntro({ skip: opts.skipIntro });
+
+  const scopeFlags = await pickScope(opts);
+  const scope = resolveScope({ global: scopeFlags.global });
+  const lock = await readLock(scope.lockPath);
+
+  if (!lock || !Object.keys(lock.skills).length) {
+    console.log(`No skills installed. Lockfile not found at: ${scope.lockPath}`);
+    outro('');
+    return;
+  }
+
+  const installed = Object.keys(lock.skills).sort();
+
+  const selected = await multiselect({
+    message: 'Select skills to remove:',
+    options: installed.map(n => ({ value: n, label: n })),
+    required: false,
+  });
+
+  if (isCancel(selected)) throw new CliCancel();
+  if (!selected?.length) { outro('Nothing selected.'); return; }
+
+  if (!opts.yes) {
+    const proceed = await confirmProceed(`Remove ${selected.length} skill(s)?`);
+    if (!proceed) { outro('Cancelled. No changes made.'); return; }
+  }
+
+  const removed = [], failed = [];
+  for (const name of selected) {
+    try {
+      const dest = join(scope.skillsDir, name);
+      if (await pathExists(dest)) await rm(dest, { recursive: true, force: true });
+      if (scope.agentsSkillsDir) {
+        const agentDest = join(scope.agentsSkillsDir, name);
+        if (await pathExists(agentDest)) await rm(agentDest, { recursive: true, force: true });
+      }
+      removeSkill(lock, name);
+      removed.push(name);
+    } catch (e) {
+      failed.push({ name, error: e.message });
+    }
+  }
+  await writeLock(scope.lockPath, lock);
+
+  note(renderRemoveSummary({ scope: scope.scope, skillsDir: scope.skillsDir, lockPath: scope.lockPath, removed, failed }), 'Removed');
+  outro(removed.length > 0 ? `Removed ${removed.length} skill(s). Restart Claude Code.` : 'Nothing removed.');
+}

package/commands/sync.js

@@ -0,0 +1,66 @@
+import { note, outro } from '@clack/prompts';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { showIntro } from '../lib/banner.js';
+import { readLock, writeLock, upsertSkill } from '../lib/lockfile.js';
+import { resolveScope, ensureDirs } from '../lib/scope.js';
+import { pickScope } from '../lib/prompts.js';
+import { materialize, pathExists, isBroken, diskType } from '../lib/install.js';
+import { hashSkill } from '../lib/hash.js';
+import { renderSyncSummary } from '../lib/summary.js';
+
+const BUNDLE_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'bundled-skills');
+
+export async function runSync(opts = {}) {
+  await showIntro({ skip: opts.skipIntro });
+
+  const scopeFlags = await pickScope(opts);
+  const scope = resolveScope({ global: scopeFlags.global });
+  const lock = await readLock(scope.lockPath);
+
+  if (!lock || !Object.keys(lock.skills).length) {
+    note(`No lockfile found at ${scope.lockPath}.\nRun "Add Skill(s)" first.`, 'Nothing to sync');
+    outro('');
+    return;
+  }
+
+  await ensureDirs(scope);
+  const synced = [], ok = [];
+
+  for (const [name, entry] of Object.entries(lock.skills).sort()) {
+    const dest = join(scope.skillsDir, name);
+    const src = join(BUNDLE_DIR, name);
+
+    if (!existsSync(src)) {
+      console.warn(`  Warning: "${name}" in lockfile but missing from bundle — skipping.`);
+      ok.push(name);
+      continue;
+    }
+
+    const ex = await pathExists(dest);
+    const broken = ex && await isBroken(dest);
+    const onDisk = await diskType(dest);
+    const wantCopy = entry.linkType === 'copy';
+    const typeMismatch = onDisk !== 'missing' &&
+      ((wantCopy && onDisk === 'symlink') || (!wantCopy && onDisk === 'copy'));
+
+    if (ex && !broken && !typeMismatch) { ok.push(name); continue; }
+
+    const lt = await materialize({ src, dest, copy: wantCopy });
+    if (scope.agentsSkillsDir) {
+      await materialize({ src, dest: join(scope.agentsSkillsDir, name), copy: wantCopy });
+    }
+    upsertSkill(lock, name, { computedHash: await hashSkill(src), linkType: lt });
+    synced.push(name);
+  }
+
+  await writeLock(scope.lockPath, lock);
+
+  note(renderSyncSummary({
+    scope: scope.scope, skillsDir: scope.skillsDir, lockPath: scope.lockPath,
+    synced, ok,
+  }), 'Sync summary');
+
+  outro(synced.length > 0 ? `Synced ${synced.length} skill(s).` : 'All skills present.');
+}

package/commands/update.js

@@ -0,0 +1,70 @@
+import { multiselect, note, outro, isCancel } from '@clack/prompts';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { showIntro } from '../lib/banner.js';
+import { readLock, writeLock, upsertSkill } from '../lib/lockfile.js';
+import { resolveScope, ensureDirs } from '../lib/scope.js';
+import { pickScope, confirmProceed, CliCancel } from '../lib/prompts.js';
+import { materialize } from '../lib/install.js';
+import { hashSkill } from '../lib/hash.js';
+import { renderUpdateSummary } from '../lib/summary.js';
+
+const BUNDLE_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'bundled-skills');
+
+export async function runUpdate(opts = {}) {
+  await showIntro({ skip: opts.skipIntro });
+
+  const scopeFlags = await pickScope(opts);
+  const scope = resolveScope({ global: scopeFlags.global });
+  const lock = await readLock(scope.lockPath);
+
+  if (!lock || !Object.keys(lock.skills).length) {
+    console.log(`No skills installed. Run "add" first.`);
+    outro('');
+    return;
+  }
+
+  const updatable = [];
+  for (const [name, entry] of Object.entries(lock.skills).sort()) {
+    const bundledPath = join(BUNDLE_DIR, name);
+    if (!existsSync(bundledPath)) continue;
+    const bundledHash = await hashSkill(bundledPath);
+    if (bundledHash !== entry.computedHash) updatable.push({ name, bundledPath, linkType: entry.linkType });
+  }
+
+  if (!updatable.length) {
+    note('All installed skills are already up to date.', 'No updates available');
+    outro('Done.');
+    return;
+  }
+
+  const selected = await multiselect({
+    message: `Select skills to update (${updatable.length} available):`,
+    options: updatable.map(s => ({ value: s.name, label: s.name })),
+    required: false,
+  });
+
+  if (isCancel(selected)) throw new CliCancel();
+  if (!selected?.length) { outro('Nothing selected.'); return; }
+
+  if (!opts.yes) {
+    const proceed = await confirmProceed(`Update ${selected.length} skill(s)?`);
+    if (!proceed) { outro('Cancelled. No changes made.'); return; }
+  }
+
+  await ensureDirs(scope);
+  for (const name of selected) {
+    const skill = updatable.find(s => s.name === name);
+    const hash = await hashSkill(skill.bundledPath);
+    const lt = await materialize({ src: skill.bundledPath, dest: join(scope.skillsDir, name), copy: skill.linkType === 'copy' });
+    if (scope.agentsSkillsDir) {
+      await materialize({ src: skill.bundledPath, dest: join(scope.agentsSkillsDir, name), copy: skill.linkType === 'copy' });
+    }
+    upsertSkill(lock, name, { computedHash: hash, linkType: lt });
+  }
+  await writeLock(scope.lockPath, lock);
+
+  note(renderUpdateSummary({ scope: scope.scope, skillsDir: scope.skillsDir, lockPath: scope.lockPath, updated: selected }), 'Updated');
+  outro(`Done! ${selected.length} skill(s) updated. Restart Claude Code.`);
+}

package/index.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { runHub } from './commands/hub.js';
+import { runAdd } from './commands/add.js';
+import { runUpdate } from './commands/update.js';
+import { runRemove } from './commands/remove.js';
+import { runList } from './commands/list.js';
+import { runSync } from './commands/sync.js';
+import { runCheck } from './commands/check.js';
+import { runExport } from './commands/exportSkills.js';
+import { runImport } from './commands/importSkills.js';
+import { CliCancel } from './lib/prompts.js';
+
+const req = createRequire(import.meta.url);
+const { version } = req(join(dirname(fileURLToPath(import.meta.url)), 'package.json'));
+
+const program = new Command()
+  .name('claude-skills')
+  .description("Install and manage Pavi's Claude Code skills")
+  .version(version);
+
+program
+  .command('hub', { isDefault: true })
+  .description('Interactive menu (default) — loops until Quit or Ctrl+C')
+  .action(() => runHub());
+
+program
+  .command('add')
+  .description('Install skills')
+  .option('-g, --global', 'Install globally (~/.claude/skills)')
+  .option('-p, --project', 'Install to current project (.claude/skills)')
+  .option('--all', 'Install all skills without prompting')
+  .option('--skill <name...>', 'Specific skill(s) to install')
+  .option('--copy', 'Copy files (safe for npx)')
+  .option('--symlink', 'Create symlinks (persistent install only)')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(opts => runAdd(opts));
+
+program
+  .command('update')
+  .description('Update installed skills to latest bundled version')
+  .option('-g, --global', 'Update global skills')
+  .option('-p, --project', 'Update project skills')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(opts => runUpdate(opts));
+
+program
+  .command('remove')
+  .description('Remove installed skills')
+  .option('-g, --global', 'Remove from global')
+  .option('-p, --project', 'Remove from project')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(opts => runRemove(opts));
+
+program
+  .command('list')
+  .description('List installed skills and their health status')
+  .option('-g, --global', 'List global skills')
+  .option('-p, --project', 'List project skills')
+  .action(opts => runList(opts));
+
+program
+  .command('sync')
+  .description('Restore skills from lockfile')
+  .option('-g, --global', 'Sync global skills')
+  .option('-p, --project', 'Sync project skills')
+  .action(opts => runSync(opts));
+
+program
+  .command('check')
+  .description('Check health and update status of installed skills')
+  .option('-g, --global', 'Check global skills')
+  .option('-p, --project', 'Check project skills')
+  .action(opts => runCheck(opts));
+
+program
+  .command('export')
+  .description('Export lockfile for sharing with teammates')
+  .option('-g, --global', 'Export global lockfile')
+  .option('-p, --project', 'Export project lockfile')
+  .option('--file <path>', 'Write to file instead of stdout')
+  .action(opts => runExport(opts));
+
+program
+  .command('import')
+  .description('Import a shared lockfile and install those skills')
+  .option('-g, --global', 'Install into global scope')
+  .option('-p, --project', 'Install into project scope')
+  .option('--file <path>', 'Lockfile to import (required)')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(opts => runImport(opts));
+
+program.parseAsync().catch(err => {
+  if (err instanceof CliCancel) process.exit(0);
+  console.error(`\nError: ${err.message}`);
+  process.exit(1);
+});

package/lib/banner.js

@@ -0,0 +1,108 @@
+import ansis from 'ansis';
+import { muted } from './theme.js';
+import { REPO } from './constants.js';
+
+const CLAUDE_LINES = [
+  ' ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗',
+  '██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝',
+  '██║     ██║     ███████║██║   ██║██║  ██║█████╗  ',
+  '██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝  ',
+  '╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗',
+  ' ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝',
+];
+
+const SKILLS_LINES = [
+  '███████╗██╗  ██╗██╗██╗     ██╗     ███████╗',
+  '██╔════╝██║ ██╔╝██║██║     ██║     ██╔════╝',
+  '███████╗█████╔╝ ██║██║     ██║     ███████╗',
+  '╚════██║██╔═██╗ ██║██║     ██║     ╚════██║',
+  '███████║██║  ██╗██║███████╗███████╗███████║',
+  '╚══════╝╚═╝  ╚═╝╚═╝╚══════╝╚══════╝╚══════╝',
+];
+
+const ART = [...CLAUDE_LINES, ...SKILLS_LINES];
+const MAX_WIDTH = Math.max(...ART.map(l => l.length));
+
+// One pride stripe per art line (12 lines → 2 lines per colour)
+const PRIDE = [
+  [220,  30,  30], // red
+  [220,  30,  30],
+  [255, 140,   0], // orange
+  [255, 140,   0],
+  [255, 210,   0], // yellow
+  [255, 210,   0],
+  [ 30, 185,  30], // green
+  [ 30, 185,  30],
+  [ 30, 100, 255], // blue
+  [ 30, 100, 255],
+  [150,  30, 230], // purple
+  [150,  30, 230],
+];
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+const col   = (r, g, b) => s => ansis.rgb(Math.round(r), Math.round(g), Math.round(b))(s);
+const up    = n => process.stdout.write(`\x1b[${n}A`);
+const wline = s => process.stdout.write(`\x1b[2K${s}\n`);
+
+function clamp(v) { return Math.max(0, Math.min(255, Math.round(v))); }
+
+/** Sheen sweep: all chars glow pride → white at the core → pride → dim */
+function sheenColor(_ch, dist, [r, g, b]) {
+  if (dist <=  1) return col(255, 255, 255);                                      // white-hot core
+  if (dist <=  3) return col(clamp(r*1.1+60), clamp(g*1.1+60), clamp(b*1.1+60)); // bright pride
+  if (dist <=  8) return col(r, g, b);                                            // pure pride
+  if (dist <= 15) return col(r * 0.7, g * 0.7, b * 0.7);                         // dimmed
+  return col(r * 0.45, g * 0.45, b * 0.45);                                      // dark base
+}
+
+/** Static settled state: sine-arc so centre is brightest (metallic highlight) */
+function staticColor(_ch, i, len, [r, g, b]) {
+  const arc = Math.sin((i / (len - 1 || 1)) * Math.PI); // 0 at edges, 1 at centre
+  const f = 0.38 + arc * 0.62;                           // 0.38 → 1.0
+  return col(r * f, g * f, b * f);
+}
+
+function renderFrame(getColor) {
+  ART.forEach((line, li) => {
+    const pride = PRIDE[li] ?? PRIDE[PRIDE.length - 1];
+    let out = '';
+    for (let i = 0; i < line.length; i++) {
+      const ch = line[i];
+      out += ch === ' ' ? ' ' : getColor(ch, i, line.length, pride)(ch);
+    }
+    wline(out);
+  });
+}
+
+async function runSweep({ step = 3, fps = 55 } = {}) {
+  const delay = Math.round(1000 / fps);
+  for (let sx = -20; sx <= MAX_WIDTH + 20; sx += step) {
+    up(ART.length);
+    renderFrame((ch, i, _len, pride) => sheenColor(ch, Math.abs(i - sx), pride));
+    await sleep(delay);
+  }
+}
+
+async function renderStatic() {
+  up(ART.length);
+  renderFrame(staticColor);
+}
+
+/**
+ * showIntro()              — full two-sweep entrance + subtitle (call ONCE at startup)
+ * showIntro({ skip:true }) — no-op (used inside sub-commands called from hub)
+ */
+export async function showIntro({ skip = false } = {}) {
+  if (skip) return;
+
+  process.stdout.write('\n'.repeat(ART.length)); // reserve block
+
+  await runSweep({ step: 3, fps: 55 }); // first sweep  (~0.8 s)
+  await runSweep({ step: 3, fps: 55 }); // second sweep (~0.8 s)
+  await renderStatic();                  // settle to metallic pride
+
+  const silver = s => ansis.rgb(190, 190, 190)(s);
+  process.stdout.write('\n');
+  process.stdout.write(silver('Agent Skills for Claude Code by Pavithran Francis') + '\n\n');
+  process.stdout.write(muted('Repository: ') + silver(REPO) + '\n\n');
+}

package/lib/constants.js

@@ -0,0 +1,10 @@
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const req = createRequire(import.meta.url);
+const pkg = req(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'));
+
+export const VERSION = pkg.version;
+export const PACKAGE_NAME = pkg.name;
+export const REPO = 'https://github.com/Pavithran-Francis/skills';

package/lib/deps.js

@@ -0,0 +1,51 @@
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const req = createRequire(import.meta.url);
+
+export function loadManifest() {
+  const manifestPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'skills.json');
+  try {
+    return req(manifestPath);
+  } catch {
+    return { skills: [], dependsOn: {} };
+  }
+}
+
+/**
+ * Topological expansion: given selected skill names, resolves all transitive
+ * dependencies and returns them in install order (deps before dependents).
+ * Returns { ordered, addedBy } where addedBy maps auto-added names → who pulled them in.
+ */
+export function expandDependencies(manifest, selected) {
+  const known = new Set(manifest.skills ?? []);
+  const selectedSet = new Set(selected);
+  const addedBy = new Map();
+  const visiting = new Set();
+  const visited = new Set();
+  const ordered = [];
+
+  function visit(name, parent) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) throw new Error(`Circular skill dependency involving: ${name}`);
+    visiting.add(name);
+
+    for (const dep of (manifest.dependsOn ?? {})[name] ?? []) {
+      if (!selectedSet.has(dep) && !addedBy.has(dep)) {
+        addedBy.set(dep, name);
+      }
+      visit(dep, name);
+    }
+
+    visiting.delete(name);
+    visited.add(name);
+    ordered.push(name);
+  }
+
+  for (const name of selected) {
+    visit(name, null);
+  }
+
+  return { ordered, addedBy };
+}