@girardmedia/bootspring 1.1.0

package/cli/quality.js

@@ -0,0 +1,332 @@
+/**
+ * Bootspring Quality Command
+ * Run quality gates and checks
+ *
+ * @package bootspring
+ * @command quality
+ */
+
+const { execSync, spawn } = require('child_process');
+const path = require('path');
+const config = require('../core/config');
+const utils = require('../core/utils');
+
+/**
+ * Quality gate definitions
+ */
+const GATES = {
+  'pre-commit': {
+    name: 'Pre-Commit',
+    description: 'Quick checks before committing code',
+    checks: [
+      {
+        name: 'TypeScript',
+        command: 'npx tsc --noEmit',
+        description: 'Type checking'
+      },
+      {
+        name: 'ESLint',
+        command: 'npx eslint . --ext .ts,.tsx,.js,.jsx --max-warnings 0',
+        description: 'Linting'
+      },
+      {
+        name: 'Prettier',
+        command: 'npx prettier --check .',
+        description: 'Format checking'
+      }
+    ]
+  },
+  'pre-push': {
+    name: 'Pre-Push',
+    description: 'Thorough checks before pushing to remote',
+    checks: [
+      {
+        name: 'TypeScript',
+        command: 'npx tsc --noEmit',
+        description: 'Type checking'
+      },
+      {
+        name: 'ESLint',
+        command: 'npx eslint . --ext .ts,.tsx,.js,.jsx',
+        description: 'Linting'
+      },
+      {
+        name: 'Unit Tests',
+        command: 'npm test',
+        description: 'Running tests'
+      },
+      {
+        name: 'Build',
+        command: 'npm run build',
+        description: 'Production build'
+      }
+    ]
+  },
+  'pre-deploy': {
+    name: 'Pre-Deploy',
+    description: 'Full audit before deployment',
+    checks: [
+      {
+        name: 'TypeScript',
+        command: 'npx tsc --noEmit',
+        description: 'Type checking'
+      },
+      {
+        name: 'ESLint',
+        command: 'npx eslint . --ext .ts,.tsx,.js,.jsx',
+        description: 'Linting'
+      },
+      {
+        name: 'Unit Tests',
+        command: 'npm test',
+        description: 'Running tests'
+      },
+      {
+        name: 'Build',
+        command: 'npm run build',
+        description: 'Production build'
+      },
+      {
+        name: 'Security Audit',
+        command: 'npm audit --audit-level=high',
+        description: 'Checking for vulnerabilities'
+      }
+    ]
+  }
+};
+
+/**
+ * Run a single check
+ * @param {object} check - Check definition
+ * @param {string} projectRoot - Project root path
+ * @returns {object} Check result
+ */
+function runCheck(check, projectRoot) {
+  const spinner = utils.createSpinner(`${check.name}: ${check.description}`).start();
+
+  try {
+    execSync(check.command, {
+      cwd: projectRoot,
+      stdio: 'pipe',
+      encoding: 'utf-8',
+      timeout: 300000 // 5 minute timeout
+    });
+
+    spinner.succeed(`${check.name}: passed`);
+    return { name: check.name, status: 'pass', message: 'Passed' };
+  } catch (error) {
+    const output = error.stdout || error.stderr || error.message;
+    spinner.fail(`${check.name}: failed`);
+
+    // Show truncated output
+    if (output) {
+      const lines = output.split('\n').slice(0, 10);
+      console.log(`${utils.COLORS.dim}${lines.join('\n')}${utils.COLORS.reset}`);
+      if (output.split('\n').length > 10) {
+        console.log(`${utils.COLORS.dim}... (truncated)${utils.COLORS.reset}`);
+      }
+    }
+
+    return { name: check.name, status: 'fail', message: output.slice(0, 500) };
+  }
+}
+
+/**
+ * Run a quality gate
+ * @param {string} gateName - Gate name
+ * @param {object} options - Options
+ */
+async function runGate(gateName, options = {}) {
+  const gate = GATES[gateName];
+
+  if (!gate) {
+    utils.print.error(`Unknown gate: ${gateName}`);
+    utils.print.dim(`Available gates: ${Object.keys(GATES).join(', ')}`);
+    return;
+  }
+
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ ${gate.name} Quality Gate${utils.COLORS.reset}
+${utils.COLORS.dim}${gate.description}${utils.COLORS.reset}
+`);
+
+  const results = [];
+  let passed = 0;
+  let failed = 0;
+
+  for (const check of gate.checks) {
+    if (options.skip && options.skip.includes(check.name.toLowerCase())) {
+      console.log(`${utils.COLORS.yellow}⊘${utils.COLORS.reset} ${check.name}: skipped`);
+      results.push({ name: check.name, status: 'skip', message: 'Skipped' });
+      continue;
+    }
+
+    const result = runCheck(check, projectRoot);
+    results.push(result);
+
+    if (result.status === 'pass') {
+      passed++;
+    } else {
+      failed++;
+    }
+
+    // Stop on first failure if strict mode
+    if (options.strict && result.status === 'fail') {
+      console.log(`\n${utils.COLORS.red}Stopping on first failure (strict mode)${utils.COLORS.reset}`);
+      break;
+    }
+  }
+
+  // Summary
+  console.log();
+  if (failed === 0) {
+    console.log(`${utils.COLORS.green}${utils.COLORS.bold}✓ All checks passed!${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}${passed} check(s) passed${utils.COLORS.reset}`);
+  } else {
+    console.log(`${utils.COLORS.red}${utils.COLORS.bold}✗ Quality gate failed${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}${passed} passed, ${failed} failed${utils.COLORS.reset}`);
+    process.exitCode = 1;
+  }
+
+  return { gate: gateName, passed, failed, results };
+}
+
+/**
+ * Run quick lint check
+ */
+function runQuickCheck() {
+  const cfg = config.load();
+  const projectRoot = cfg._projectRoot;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Quick Quality Check${utils.COLORS.reset}
+`);
+
+  // Just run TypeScript check
+  const spinner = utils.createSpinner('Type checking...').start();
+
+  try {
+    execSync('npx tsc --noEmit', {
+      cwd: projectRoot,
+      stdio: 'pipe',
+      timeout: 60000
+    });
+    spinner.succeed('No type errors');
+  } catch (error) {
+    spinner.fail('Type errors found');
+    console.log(`${utils.COLORS.dim}Run 'npx tsc --noEmit' for details${utils.COLORS.reset}`);
+  }
+}
+
+/**
+ * Show quality status
+ */
+function showStatus() {
+  const cfg = config.load();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Quality Gate Configuration${utils.COLORS.reset}
+${utils.COLORS.dim}Project: ${cfg._projectRoot}${utils.COLORS.reset}
+
+${utils.COLORS.bold}Available Gates${utils.COLORS.reset}
+`);
+
+  for (const [id, gate] of Object.entries(GATES)) {
+    console.log(`  ${utils.COLORS.cyan}${id}${utils.COLORS.reset}`);
+    console.log(`    ${gate.description}`);
+    console.log(`    ${utils.COLORS.dim}Checks: ${gate.checks.map(c => c.name).join(', ')}${utils.COLORS.reset}`);
+    console.log();
+  }
+
+  const userConfig = cfg.quality || {};
+  console.log(`${utils.COLORS.bold}Project Settings${utils.COLORS.reset}`);
+  console.log(`  Pre-commit: ${userConfig.preCommit !== false ? 'enabled' : 'disabled'}`);
+  console.log(`  Pre-push: ${userConfig.prePush ? 'enabled' : 'disabled'}`);
+  console.log(`  Strict mode: ${userConfig.strictMode ? 'enabled' : 'disabled'}`);
+  console.log();
+
+  console.log(`${utils.COLORS.bold}Git Hooks${utils.COLORS.reset}`);
+  console.log(`  ${utils.COLORS.dim}To enable git hooks, use husky or lefthook:${utils.COLORS.reset}`);
+  console.log(`  ${utils.COLORS.dim}npx husky add .husky/pre-commit "bootspring quality pre-commit"${utils.COLORS.reset}`);
+}
+
+/**
+ * Show quality help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Quality${utils.COLORS.reset}
+${utils.COLORS.dim}Run quality gates and checks${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring quality <gate> [options]
+
+${utils.COLORS.bold}Gates:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}pre-commit${utils.COLORS.reset}        Quick checks (types, lint, format)
+  ${utils.COLORS.cyan}pre-push${utils.COLORS.reset}          Thorough checks (tests, build)
+  ${utils.COLORS.cyan}pre-deploy${utils.COLORS.reset}        Full audit (security, everything)
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  --strict          Stop on first failure
+  --skip <check>    Skip specific check
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}quick${utils.COLORS.reset}             Run quick type check only
+  ${utils.COLORS.cyan}status${utils.COLORS.reset}            Show quality configuration
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring quality pre-commit
+  bootspring quality pre-push --strict
+  bootspring quality pre-deploy --skip security
+  bootspring quality quick
+  bootspring quality status
+`);
+}
+
+/**
+ * Run quality command
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0];
+
+  if (!subcommand) {
+    showHelp();
+    return;
+  }
+
+  switch (subcommand) {
+    case 'pre-commit':
+    case 'pre-push':
+    case 'pre-deploy':
+      await runGate(subcommand, {
+        strict: parsedArgs.strict,
+        skip: parsedArgs.skip ? [parsedArgs.skip] : []
+      });
+      break;
+
+    case 'quick':
+    case 'check':
+      runQuickCheck();
+      break;
+
+    case 'status':
+      showStatus();
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      break;
+
+    default:
+      utils.print.error(`Unknown gate: ${subcommand}`);
+      showHelp();
+  }
+}
+
+module.exports = { run, GATES, runGate, runCheck };

package/cli/skill.js

@@ -0,0 +1,369 @@
+/**
+ * Bootspring Skill Command
+ * Browse and use skill patterns.
+ */
+
+const utils = require('../core/utils');
+const entitlements = require('../core/entitlements');
+const telemetry = require('../core/telemetry');
+const skills = require('../skills');
+
+function trackTelemetry(event, payload) {
+  try {
+    telemetry.emitEvent(event, payload);
+  } catch {
+    // Do not block CLI flow on telemetry issues.
+  }
+}
+
+function printBuiltInSkills() {
+  const categories = skills.getCategories();
+  for (const category of categories) {
+    const patterns = skills.getPatternsByCategory(category);
+    if (patterns.length === 0) continue;
+
+    console.log(`${utils.COLORS.bold}${category}${utils.COLORS.reset}`);
+    for (const pattern of patterns) {
+      const id = `${category}/${pattern}`;
+      const metadata = skills.getSkillMetadata(id);
+      const description = metadata?.description ? ` - ${metadata.description}` : '';
+      console.log(`  ${utils.COLORS.cyan}${id}${utils.COLORS.reset}${description}`);
+    }
+    console.log('');
+  }
+}
+
+function printExternalSkills(options = {}) {
+  const {
+    limit = 20,
+    accessOptions = {}
+  } = options;
+
+  if (!skills.hasExternalSkillLibrary()) {
+    console.log(`${utils.COLORS.dim}No external skills catalog found${utils.COLORS.reset}\n`);
+    return;
+  }
+
+  const externalIds = skills.listExternalSkills();
+  const { allowed: accessibleIds, denied } = entitlements.filterAccessibleSkills(externalIds, accessOptions);
+  const shown = accessibleIds.slice(0, limit);
+
+  if (shown.length === 0) {
+    console.log(`${utils.COLORS.bold}external${utils.COLORS.reset}`);
+    console.log(`  ${utils.COLORS.dim}No external skills available for current entitlement${utils.COLORS.reset}\n`);
+    if (denied.length > 0) {
+      utils.print.dim(denied[0].reason);
+    }
+    return;
+  }
+
+  console.log(`${utils.COLORS.bold}external${utils.COLORS.reset}`);
+  for (const id of shown) {
+    const metadata = skills.getSkillMetadata(id);
+    const description = metadata?.description ? ` - ${metadata.description}` : '';
+    console.log(`  ${utils.COLORS.yellow}${id}${utils.COLORS.reset}${description}`);
+  }
+
+  if (accessibleIds.length > shown.length) {
+    const remaining = accessibleIds.length - shown.length;
+    console.log(`\n${utils.COLORS.dim}${remaining} more external skills hidden.${utils.COLORS.reset}`);
+    console.log(`${utils.COLORS.dim}Use --limit <n> or search with --external.${utils.COLORS.reset}`);
+  }
+  if (denied.length > 0) {
+    console.log(`\n${utils.COLORS.dim}${denied.length} external skills locked by entitlement policy${utils.COLORS.reset}`);
+  }
+  console.log('');
+}
+
+function listSkills(options = {}) {
+  const {
+    includeExternal = false,
+    externalOnly = false,
+    limit = 20,
+    accessOptions = {}
+  } = options;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Skills${utils.COLORS.reset}
+${utils.COLORS.dim}Built-in patterns + optional external skill catalog${utils.COLORS.reset}
+`);
+
+  if (!externalOnly) {
+    printBuiltInSkills();
+  }
+
+  if (includeExternal || externalOnly) {
+    printExternalSkills({ limit, accessOptions });
+  }
+
+  const builtInCount = skills.listSkills().length;
+  const externalCount = skills.hasExternalSkillLibrary() ? skills.listExternalSkills().length : 0;
+  console.log(`${utils.COLORS.dim}${builtInCount} built-in skills available${utils.COLORS.reset}`);
+  if (skills.hasExternalSkillLibrary()) {
+    console.log(`${utils.COLORS.dim}${externalCount} external skills indexed${utils.COLORS.reset}`);
+  }
+  console.log(`${utils.COLORS.dim}Use "bootspring skill show <id>" to view a skill${utils.COLORS.reset}`);
+}
+
+function showSkill(skillId, options = {}) {
+  const {
+    includeExternal = false,
+    summary = false,
+    sections,
+    maxChars,
+    accessOptions = {}
+  } = options;
+
+  const metadata = skills.getSkillMetadata(skillId);
+  const resolvedSkillId = metadata?.id || skillId;
+  const access = entitlements.checkSkillAccess(resolvedSkillId, accessOptions);
+
+  if (!access.allowed) {
+    trackTelemetry('premium_prompted', {
+      capability: 'external_skill',
+      skillId: resolvedSkillId,
+      mode: access.context?.mode,
+      tier: access.context?.tier,
+      reason: access.code
+    });
+    utils.print.error(access.reason);
+    return;
+  }
+
+  const rawContent = skills.loadSkill(skillId, { includeExternal });
+
+  if (!rawContent) {
+    utils.print.error(`Skill not found: ${skillId}`);
+    utils.print.dim('Try: bootspring skill list');
+    utils.print.dim('Or: bootspring skill search <query> --external');
+    return;
+  }
+
+  const content = skills.formatSkillContent(rawContent, {
+    summary,
+    sections,
+    maxChars
+  });
+
+  const headerName = metadata?.name || skillId;
+  const source = metadata?.source || 'built-in';
+  if (String(source).startsWith('external')) {
+    trackTelemetry('premium_unlocked', {
+      capability: 'external_skill',
+      skillId: metadata?.id || skillId,
+      mode: access.context?.mode,
+      tier: access.context?.tier,
+      reason: access.code
+    });
+  }
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}${headerName}${utils.COLORS.reset}
+${utils.COLORS.dim}ID: ${metadata?.id || skillId} | Source: ${source}${utils.COLORS.reset}
+`);
+
+  console.log(content);
+}
+
+function searchSkills(query, options = {}) {
+  const {
+    includeExternal = false,
+    externalOnly = false,
+    limit = 20,
+    accessOptions = {}
+  } = options;
+
+  let results = skills.searchSkills(query, {
+    includeExternal: includeExternal || externalOnly,
+    limit
+  });
+
+  if (externalOnly) {
+    results = results.filter(id => id.startsWith('external/'));
+  }
+  const filtered = entitlements.filterAccessibleSkills(results, accessOptions);
+  results = filtered.allowed;
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Search Results${utils.COLORS.reset}
+${utils.COLORS.dim}Query: "${query}"${utils.COLORS.reset}
+`);
+
+  if (results.length === 0) {
+    utils.print.warning('No matching skills found');
+    utils.print.dim('Try: bootspring skill list');
+    return;
+  }
+
+  for (const id of results) {
+    const metadata = skills.getSkillMetadata(id);
+    const source = String(metadata?.source || '').startsWith('external') ? 'external' : 'built-in';
+    const description = metadata?.description ? ` - ${metadata.description}` : '';
+    const color = source === 'external' ? utils.COLORS.yellow : utils.COLORS.cyan;
+    console.log(`  ${color}${id}${utils.COLORS.reset} ${utils.COLORS.dim}[${source}]${utils.COLORS.reset}${description}`);
+  }
+
+  console.log(`\n${utils.COLORS.dim}${results.length} match(es)${utils.COLORS.reset}`);
+  if (filtered.denied.length > 0) {
+    console.log(`${utils.COLORS.dim}${filtered.denied.length} result(s) hidden by entitlement policy${utils.COLORS.reset}`);
+  }
+}
+
+async function syncCatalog(options = {}) {
+  const {
+    manifestUrl,
+    contentBaseUrl,
+    token,
+    timeoutMs,
+    cacheDir,
+    manifestPublicKey,
+    requireManifestSignature
+  } = options;
+
+  const spinner = utils.createSpinner('Syncing external skill catalog').start();
+  try {
+    const result = await skills.syncExternalCatalog({
+      manifestUrl,
+      contentBaseUrl,
+      token,
+      timeoutMs,
+      cacheDir,
+      manifestPublicKey,
+      requireManifestSignature
+    });
+    spinner.succeed(`Synced ${result.fetched} external skills`);
+    if (result.skipped.length > 0) {
+      utils.print.warning(`Skipped ${result.skipped.length} skill(s): ${result.skipped.join(', ')}`);
+    }
+    utils.print.dim(`Cache: ${result.manifestPath}`);
+  } catch (error) {
+    spinner.fail(`Sync failed: ${error.message}`);
+  }
+}
+
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring Skill Command${utils.COLORS.reset}
+
+${utils.COLORS.cyan}Usage:${utils.COLORS.reset}
+  bootspring skill <command> [args] [options]
+
+${utils.COLORS.cyan}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}list${utils.COLORS.reset}                      List built-in skills
+  ${utils.COLORS.cyan}show${utils.COLORS.reset} <id>                 Show skill content
+  ${utils.COLORS.cyan}search${utils.COLORS.reset} <query>            Search skills
+  ${utils.COLORS.cyan}sync${utils.COLORS.reset}                      Sync external catalog from remote manifest
+
+${utils.COLORS.cyan}Options:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}--external${utils.COLORS.reset}                Include external skills catalog
+  ${utils.COLORS.cyan}--external-only${utils.COLORS.reset}           External skills only
+  ${utils.COLORS.cyan}--limit <n>${utils.COLORS.reset}               Limit results (default: 20)
+  ${utils.COLORS.cyan}--summary${utils.COLORS.reset}                 Show concise summary for skill show
+  ${utils.COLORS.cyan}--sections a,b${utils.COLORS.reset}            Show matching sections for skill show
+  ${utils.COLORS.cyan}--max-chars <n>${utils.COLORS.reset}           Cap output size for skill show
+  ${utils.COLORS.cyan}--access-mode <mode>${utils.COLORS.reset}      Access mode: local (default) or server
+  ${utils.COLORS.cyan}--entitled <bool>${utils.COLORS.reset}         Entitlement override for external skills
+  ${utils.COLORS.cyan}--tier <tier>${utils.COLORS.reset}             Tier override: free, pro, team, enterprise
+  ${utils.COLORS.cyan}--manifest-url <url>${utils.COLORS.reset}      Remote manifest URL for skill sync
+  ${utils.COLORS.cyan}--content-base-url <url>${utils.COLORS.reset}  Base URL for SKILL.md files when missing contentUrl
+  ${utils.COLORS.cyan}--token <value>${utils.COLORS.reset}           Bearer token for remote catalog APIs
+  ${utils.COLORS.cyan}--cache-dir <path>${utils.COLORS.reset}        Override local skill cache directory
+  ${utils.COLORS.cyan}--manifest-public-key <pem>${utils.COLORS.reset} Public key for manifest signature verification
+  ${utils.COLORS.cyan}--require-signature <bool>${utils.COLORS.reset} Require remote manifest signature validation
+
+${utils.COLORS.cyan}Examples:${utils.COLORS.reset}
+  bootspring skill list
+  bootspring skill list --external
+  bootspring skill search auth
+  bootspring skill search vercel --external
+  bootspring skill show auth/clerk
+  bootspring skill show external/vercel-automation
+  bootspring skill sync --manifest-url https://api.bootspring.com/skills/manifest.json
+`);
+}
+
+/**
+ * Run skill command
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0] || 'list';
+  const subargs = parsedArgs._.slice(1);
+
+  const externalOnly = Boolean(parsedArgs['external-only']);
+  const includeExternal = externalOnly || Boolean(parsedArgs.external);
+  const parsedLimit = parsedArgs.limit ? Number(parsedArgs.limit) : 20;
+  const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? parsedLimit : 20;
+  const maxChars = parsedArgs['max-chars'] ? Number(parsedArgs['max-chars']) : undefined;
+  const accessOptions = {
+    mode: parsedArgs['access-mode'],
+    entitled: parsedArgs.entitled,
+    tier: parsedArgs.tier
+  };
+
+  switch (subcommand) {
+    case 'list':
+      listSkills({ includeExternal, externalOnly, limit, accessOptions });
+      break;
+
+    case 'show':
+      if (!subargs[0]) {
+        utils.print.error('Please specify a skill ID');
+        utils.print.dim('Usage: bootspring skill show <id>');
+        return;
+      }
+      showSkill(subargs[0], {
+        includeExternal: true,
+        summary: Boolean(parsedArgs.summary),
+        sections: parsedArgs.sections,
+        maxChars,
+        accessOptions
+      });
+      break;
+
+    case 'search':
+      if (!subargs[0]) {
+        utils.print.error('Please specify a search query');
+        utils.print.dim('Usage: bootspring skill search <query>');
+        return;
+      }
+      searchSkills(subargs.join(' '), { includeExternal, externalOnly, limit, accessOptions });
+      break;
+
+    case 'sync':
+      await syncCatalog({
+        manifestUrl: parsedArgs['manifest-url'],
+        contentBaseUrl: parsedArgs['content-base-url'],
+        token: parsedArgs.token,
+        timeoutMs: parsedArgs.timeout,
+        cacheDir: parsedArgs['cache-dir'],
+        manifestPublicKey: parsedArgs['manifest-public-key'],
+        requireManifestSignature: parsedArgs['require-signature']
+      });
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      break;
+
+    default:
+      // Shortcut: `bootspring skill auth/clerk`
+      showSkill(subcommand, {
+        includeExternal: true,
+        summary: Boolean(parsedArgs.summary),
+        sections: parsedArgs.sections,
+        maxChars,
+        accessOptions
+      });
+  }
+}
+
+module.exports = {
+  run,
+  listSkills,
+  showSkill,
+  searchSkills,
+  syncCatalog
+};