@girardmedia/bootspring 2.1.2 → 2.2.0

package/cli/skill.js

@@ -1,503 +0,0 @@
-/**
- * Bootspring Skill Command
- * Browse and use skill patterns.
- */
-
-const crypto = require('crypto');
-const utils = require('../core/utils');
-const entitlements = require('../core/entitlements');
-const tierEnforcement = require('../core/tier-enforcement');
-const telemetry = require('../core/telemetry');
-const api = require('../core/api-client');
-const auth = require('../core/auth');
-
-// Note: skills module removed - all content fetched from API (thin client)
-
-function trackTelemetry(event, payload) {
-  try {
-    telemetry.emitEvent(event, payload);
-  } catch {
-    // Do not block CLI flow on telemetry issues.
-  }
-}
-
-// Use centralized tier badge formatting
-const { formatTierBadge } = tierEnforcement;
-
-function normalizeChecksum(checksum) {
-  const raw = String(checksum || '').trim().toLowerCase();
-  if (!raw) return '';
-  return raw.startsWith('sha256:') ? raw.slice(7) : raw;
-}
-
-function isPremiumTier(tier) {
-  const normalized = String(tier || 'free').trim().toLowerCase();
-  return normalized === 'pro' || normalized === 'premium';
-}
-
-function verifyPayloadIntegrity(resourceId, content, checksum, options = {}) {
-  const { requireChecksum = false } = options;
-  const expected = normalizeChecksum(checksum);
-  if (requireChecksum && !expected) {
-    throw new Error(`Integrity metadata missing for skill payload: ${resourceId}`);
-  }
-
-  const digest = crypto.createHash('sha256').update(String(content || ''), 'utf8').digest('hex');
-  if (expected && expected !== digest) {
-    throw new Error(`Integrity check failed for skill payload: ${resourceId}`);
-  }
-
-  return {
-    algorithm: 'sha256',
-    checksum: `sha256:${digest}`,
-    expected: expected ? `sha256:${expected}` : null,
-    verified: !!expected
-  };
-}
-
-/**
- * Fetch skills list from API (thin client)
- */
-async function fetchSkillsList(options = {}) {
-  if (!auth.isAuthenticated()) {
-    return { error: 'auth_required' };
-  }
-
-  try {
-    const response = await api.listSkills(options);
-    return response;
-  } catch (error) {
-    if (error.status === 401) {
-      return { error: 'auth_required' };
-    }
-    return { error: 'network_error', message: error.message };
-  }
-}
-
-/**
- * Fetch skill content from API (thin client)
- */
-async function fetchSkillContent(skillId) {
-  if (!auth.isAuthenticated()) {
-    return { error: 'auth_required' };
-  }
-
-  try {
-    const response = await api.getSkillContent(skillId);
-    const skillTier = String(response?.tier || 'free').toLowerCase();
-    const access = entitlements.checkSkillAccess(skillId, {
-      mode: 'server',
-      entitled: true,
-      tier: auth.getTier(),
-      skillTier
-    });
-
-    if (!access.allowed) {
-      return { error: 'upgrade_required', requiredTier: 'pro', message: access.reason };
-    }
-
-    const integrity = verifyPayloadIntegrity(skillId, response?.content || '', response?.checksum, {
-      requireChecksum: Boolean(response?.checksum)
-    });
-
-    return { ...response, integrity };
-  } catch (error) {
-    if (error.message && error.message.toLowerCase().includes('integrity')) {
-      return { error: 'integrity_error', message: error.message };
-    }
-    if (error.status === 403) {
-      return { error: 'upgrade_required', requiredTier: 'pro' };
-    }
-    if (error.status === 401) {
-      return { error: 'auth_required' };
-    }
-    if (error.status === 404) {
-      return { error: 'not_found' };
-    }
-    return { error: 'network_error', message: error.message };
-  }
-}
-
-/**
- * List skills from API (thin client)
- */
-async function listSkills(options = {}) {
-  const { tierFilter, category } = options;
-
-  // Check authentication
-  if (!auth.isAuthenticated()) {
-    console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Skills${utils.COLORS.reset}
-${utils.COLORS.red}Authentication required${utils.COLORS.reset}
-
-${utils.COLORS.dim}Skills are served from the API. Please log in:${utils.COLORS.reset}
-  ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset}
-`);
-    return;
-  }
-
-  const tierLabel = tierFilter ? ` (${tierFilter} tier)` : '';
-  console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Skills${utils.COLORS.reset}${tierLabel}
-${utils.COLORS.dim}Code patterns served from API${utils.COLORS.reset}
-`);
-
-  const spinner = utils.createSpinner('Loading skills...');
-  spinner.start();
-
-  const result = await fetchSkillsList({ category });
-
-  if (result.error === 'auth_required') {
-    spinner.fail('Authentication required');
-    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
-    return;
-  }
-
-  if (result.error === 'network_error') {
-    spinner.fail('Failed to load skills');
-    console.log(`${utils.COLORS.dim}Check your internet connection.${utils.COLORS.reset}`);
-    return;
-  }
-
-  spinner.succeed(`Loaded ${result.skills?.length || 0} skills`);
-
-  // Group skills by category
-  const categories = {};
-  for (const skill of result.skills || []) {
-    // Apply tier filter if specified
-    if (tierFilter && skill.tier !== tierFilter) continue;
-
-    if (!categories[skill.category]) {
-      categories[skill.category] = [];
-    }
-    categories[skill.category].push(skill);
-  }
-
-  // Display by category
-  for (const [cat, catSkills] of Object.entries(categories).sort()) {
-    console.log(`\n${utils.COLORS.bold}${cat}${utils.COLORS.reset}`);
-    for (const skill of catSkills) {
-      const tierBadge = formatTierBadge(skill.tier);
-      const lockIcon = skill.accessible ? '' : ` ${utils.COLORS.red}🔒${utils.COLORS.reset}`;
-      const description = skill.description ? ` - ${skill.description}` : '';
-      console.log(`  ${utils.COLORS.cyan}${skill.id}${utils.COLORS.reset} ${tierBadge}${lockIcon}${description}`);
-    }
-  }
-
-  const accessibleCount = (result.skills || []).filter(s => s.accessible).length;
-  const lockedCount = (result.skills || []).length - accessibleCount;
-
-  console.log(`\n${utils.COLORS.dim}${accessibleCount} skills available, ${lockedCount} locked${utils.COLORS.reset}`);
-  console.log(`${utils.COLORS.dim}Your tier: ${result.userTier || 'free'}${utils.COLORS.reset}`);
-  console.log(`${utils.COLORS.dim}Use "bootspring skill show <id>" to view a skill${utils.COLORS.reset}`);
-}
-
-/**
- * Show skill content from API (thin client)
- */
-async function showSkill(skillId, _options = {}) {
-  // Check authentication first
-  if (!auth.isAuthenticated()) {
-    console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Skill: ${skillId}${utils.COLORS.reset}
-${utils.COLORS.red}Authentication required${utils.COLORS.reset}
-
-${utils.COLORS.dim}Skill content is served from the API. Please log in:${utils.COLORS.reset}
-  ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset}
-`);
-    return;
-  }
-
-  const isMCP = utils.isMCPContext();
-
-  const spinner = utils.createSpinner('Loading skill...');
-  spinner.start();
-
-  const result = await fetchSkillContent(skillId);
-
-  if (result.error === 'auth_required') {
-    spinner.fail('Authentication required');
-    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
-    return;
-  }
-
-  if (result.error === 'upgrade_required') {
-    spinner.fail('Upgrade required');
-    const promptContext = tierEnforcement.getUpgradePromptContext(`skill: ${skillId}`, result.requiredTier || 'pro', {
-      capability: 'premium_pattern',
-      action: 'skill_show'
-    });
-    trackTelemetry('premium_prompted', {
-      skillId,
-      ...promptContext,
-      reason: 'upgrade_required'
-    });
-    console.log(tierEnforcement.getUpgradePrompt(`skill: ${skillId}`, result.requiredTier || 'pro', {
-      capability: promptContext.capability,
-      action: promptContext.action,
-      placement: promptContext.placement,
-      variant: promptContext.variant
-    }));
-    return;
-  }
-
-  if (result.error === 'not_found') {
-    spinner.fail('Skill not found');
-    utils.print.dim('Try: bootspring skill list');
-    return;
-  }
-
-  if (result.error === 'integrity_error') {
-    spinner.fail('Integrity verification failed');
-    console.log(`${utils.COLORS.dim}${result.message || 'Skill payload checksum mismatch.'}${utils.COLORS.reset}`);
-    return;
-  }
-
-  if (result.error === 'network_error') {
-    spinner.fail('Failed to load skill');
-    console.log(`${utils.COLORS.dim}Check your internet connection.${utils.COLORS.reset}`);
-    return;
-  }
-
-  spinner.succeed('Skill loaded');
-
-  const tierBadge = formatTierBadge(result.tier || 'free');
-
-  console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}${result.name || skillId}${utils.COLORS.reset} ${tierBadge}
-${utils.COLORS.dim}ID: ${result.id || skillId} | Tier: ${result.tier || 'free'}${utils.COLORS.reset}
-`);
-
-  // Track successful access
-  trackTelemetry('skill_accessed', {
-    skillId: result.id || skillId,
-    tier: result.tier
-  });
-
-  const unlockedPremium = entitlements.isExternalSkill(result.id || skillId) || isPremiumTier(result.tier);
-  if (unlockedPremium) {
-    const promptContext = tierEnforcement.getUpgradePromptContext(`skill: ${result.id || skillId}`, String(result.tier || 'pro'), {
-      capability: entitlements.isExternalSkill(result.id || skillId) ? 'external_skill' : 'premium_pattern',
-      action: 'skill_show'
-    });
-    trackTelemetry('premium_unlocked', {
-      skillId: result.id || skillId,
-      skillTier: result.tier || 'free',
-      ...promptContext
-    });
-  }
-
-  // In MCP mode, output full content
-  if (isMCP) {
-    console.log(result.content);
-    return;
-  }
-
-  // CLI mode - show content with truncation notice
-  const contentLines = result.content.split('\n');
-  const previewLines = contentLines.slice(0, 40);
-  const hasMore = contentLines.length > 40;
-
-  console.log(previewLines.join('\n'));
-
-  if (hasMore) {
-    console.log(`\n${utils.COLORS.dim}... (${contentLines.length - 40} more lines)${utils.COLORS.reset}`);
-  }
-
-  console.log(`
-${utils.COLORS.bold}Usage:${utils.COLORS.reset}
-  Copy the pattern above and adapt it to your project.
-
-${utils.COLORS.yellow}${utils.COLORS.bold}Full Content in MCP Mode${utils.COLORS.reset}
-${utils.COLORS.dim}With MCP integration, skills are available directly in your AI assistant.${utils.COLORS.reset}
-  ${utils.COLORS.cyan}bootspring mcp start${utils.COLORS.reset}
-`);
-}
-
-/**
- * Search skills via API (thin client)
- */
-async function searchSkills(query, options = {}) {
-  const { tierFilter } = options;
-
-  // Check authentication
-  if (!auth.isAuthenticated()) {
-    console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}Search: "${query}"${utils.COLORS.reset}
-${utils.COLORS.red}Authentication required${utils.COLORS.reset}
-
-${utils.COLORS.dim}Skills are served from the API. Please log in:${utils.COLORS.reset}
-  ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset}
-`);
-    return;
-  }
-
-  const spinner = utils.createSpinner('Searching...');
-  spinner.start();
-
-  const result = await fetchSkillsList({ search: query });
-
-  if (result.error) {
-    spinner.fail('Search failed');
-    console.log(`${utils.COLORS.dim}${result.message || 'Check your internet connection.'}${utils.COLORS.reset}`);
-    return;
-  }
-
-  spinner.succeed('Search complete');
-
-  let skills = result.skills || [];
-
-  // Apply tier filter if specified
-  if (tierFilter) {
-    skills = skills.filter(s => s.tier === tierFilter);
-  }
-
-  const tierLabel = tierFilter ? ` (${tierFilter} tier)` : '';
-  console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}Search Results${utils.COLORS.reset}${tierLabel}
-${utils.COLORS.dim}Query: "${query}"${utils.COLORS.reset}
-`);
-
-  if (skills.length === 0) {
-    utils.print.warning('No matching skills found');
-    utils.print.dim('Try: bootspring skill list');
-    return;
-  }
-
-  for (const skill of skills) {
-    const tierBadge = formatTierBadge(skill.tier);
-    const lockIcon = skill.accessible ? '' : ` ${utils.COLORS.red}🔒${utils.COLORS.reset}`;
-    const description = skill.description ? ` - ${skill.description}` : '';
-    console.log(`  ${utils.COLORS.cyan}${skill.id}${utils.COLORS.reset} ${tierBadge}${lockIcon}${description}`);
-  }
-
-  const accessibleCount = skills.filter(s => s.accessible).length;
-  const lockedCount = skills.length - accessibleCount;
-
-  console.log(`\n${utils.COLORS.dim}${skills.length} match(es)${utils.COLORS.reset}`);
-  if (lockedCount > 0) {
-    console.log(`${utils.COLORS.dim}${lockedCount} result(s) require upgrade${utils.COLORS.reset}`);
-    console.log(`${utils.COLORS.dim}Run: bootspring billing upgrade${utils.COLORS.reset}`);
-  }
-}
-
-/**
- * Sync is no longer needed - thin client fetches from API
- * @deprecated
- */
-async function syncCatalog() {
-  console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}Sync Not Required${utils.COLORS.reset}
-
-${utils.COLORS.dim}Skills are now served directly from the API.${utils.COLORS.reset}
-${utils.COLORS.dim}No local sync needed - content is always up to date.${utils.COLORS.reset}
-
-${utils.COLORS.bold}To view available skills:${utils.COLORS.reset}
-  ${utils.COLORS.cyan}bootspring skill list${utils.COLORS.reset}
-`);
-}
-
-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}Options:${utils.COLORS.reset}
-  ${utils.COLORS.cyan}--tier-filter <tier>${utils.COLORS.reset}      Filter by tier: free or pro
-  ${utils.COLORS.cyan}--category <cat>${utils.COLORS.reset}          Filter by category
-
-${utils.COLORS.cyan}Tier Information:${utils.COLORS.reset}
-  Skills are labeled with their tier: ${utils.COLORS.green}[FREE]${utils.COLORS.reset} or ${utils.COLORS.yellow}[PRO]${utils.COLORS.reset}
-  - FREE tier patterns are available to all authenticated users
-  - PRO tier patterns require a Pro subscription
-
-${utils.COLORS.cyan}Authentication:${utils.COLORS.reset}
-  All skill commands require authentication.
-  Run: ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset}
-
-${utils.COLORS.cyan}Examples:${utils.COLORS.reset}
-  bootspring skill list
-  bootspring skill list --tier-filter=free
-  bootspring skill search auth
-  bootspring skill show auth/clerk
-  bootspring skill show api/route-handler
-`);
-}
-
-/**
- * Normalize tier filter value
- */
-function normalizeTierFilter(value) {
-  if (!value) return undefined;
-  const normalized = String(value).trim().toLowerCase();
-  if (normalized === 'free' || normalized === 'pro' || normalized === 'premium') {
-    // Treat 'premium' as 'pro' for filtering purposes
-    return normalized === 'premium' ? 'pro' : normalized;
-  }
-  return undefined;
-}
-
-/**
- * Run skill command
- */
-async function run(args) {
-  const parsedArgs = utils.parseArgs(args);
-  const subcommand = parsedArgs._[0] || 'list';
-  const subargs = parsedArgs._.slice(1);
-
-  // Parse tier filter (for list/search filtering) separately from access tier
-  const tierFilter = normalizeTierFilter(parsedArgs['tier-filter'] || parsedArgs['filter-tier']);
-
-  switch (subcommand) {
-    case 'list':
-      await listSkills({ tierFilter, category: parsedArgs.category });
-      break;
-
-    case 'show':
-      if (!subargs[0]) {
-        utils.print.error('Please specify a skill ID');
-        utils.print.dim('Usage: bootspring skill show <id>');
-        return;
-      }
-      await showSkill(subargs[0], {});
-      break;
-
-    case 'search':
-      if (!subargs[0]) {
-        utils.print.error('Please specify a search query');
-        utils.print.dim('Usage: bootspring skill search <query>');
-        return;
-      }
-      await searchSkills(subargs.join(' '), { tierFilter });
-      break;
-
-    case 'sync':
-      await syncCatalog();
-      break;
-
-    case 'help':
-    case '-h':
-    case '--help':
-      showHelp();
-      break;
-
-    default:
-      // Shortcut: `bootspring skill auth/clerk`
-      await showSkill(subcommand, {});
-  }
-}
-
-module.exports = {
-  run,
-  listSkills,
-  showSkill,
-  searchSkills,
-  syncCatalog
-};