@girardmedia/bootspring 2.1.3 → 2.2.0

package/cli/agent.js

@@ -1,799 +0,0 @@
-/**
- * Bootspring Agent Command
- * Work with specialized AI agents
- *
- * @package bootspring
- * @command agent
- */
-
-const crypto = require('crypto');
-const utils = require('../core/utils');
-const telemetry = require('../core/telemetry');
-const tierEnforcement = require('../core/tier-enforcement');
-const api = require('../core/api-client');
-const auth = require('../core/auth');
-
-// Re-export AGENT_TIERS from tier-enforcement for compatibility
-const { AGENT_TIERS, checkAgentAccess: canAccessAgent } = tierEnforcement;
-
-/**
- * Track agent invocation via telemetry
- */
-function trackAgentInvocation(agentId, topic = null) {
-  try {
-    telemetry.emitEvent('agent.invoked', {
-      agent: agentId,
-      topic: topic ? topic.substring(0, 100) : null, // Truncate for privacy
-      timestamp: new Date().toISOString()
-    });
-  } catch {
-    // Telemetry should never break the command
-  }
-}
-
-function trackTelemetry(event, payload = {}) {
-  try {
-    telemetry.emitEvent(event, payload);
-  } catch {
-    // Never block command flow on telemetry issues.
-  }
-}
-
-function getUpgradePromptContext(agentId, requiredTier = 'pro') {
-  if (typeof tierEnforcement.getUpgradePromptContext === 'function') {
-    return tierEnforcement.getUpgradePromptContext(`agent: ${agentId}`, requiredTier, {
-      capability: 'agent_access',
-      action: 'agent_invoke'
-    });
-  }
-
-  return {
-    feature: `agent: ${agentId}`,
-    featureType: 'agent',
-    featureLabel: `Agent ${agentId}`,
-    capability: 'agent_access',
-    action: 'agent_invoke',
-    requiredTier,
-    userTier: typeof tierEnforcement.getTier === 'function' ? tierEnforcement.getTier() : 'free',
-    placement: 'inline',
-    variant: 'control'
-  };
-}
-
-function trackUpgradePrompted(agentId, requiredTier, reason = 'agent_subscription_required') {
-  const promptContext = getUpgradePromptContext(agentId, requiredTier || 'pro');
-  trackTelemetry('premium_prompted', {
-    ...promptContext,
-    agent: agentId,
-    reason
-  });
-  return promptContext;
-}
-
-function trackUpgradeUnlocked(agentId, requiredTier) {
-  const promptContext = getUpgradePromptContext(agentId, requiredTier || 'pro');
-  trackTelemetry('premium_unlocked', {
-    ...promptContext,
-    agent: agentId
-  });
-}
-
-function normalizeChecksum(checksum) {
-  const raw = String(checksum || '').trim().toLowerCase();
-  if (!raw) return '';
-  return raw.startsWith('sha256:') ? raw.slice(7) : raw;
-}
-
-function verifyPayloadIntegrity(agentId, content, checksum, options = {}) {
-  const { requireChecksum = false } = options;
-  const expected = normalizeChecksum(checksum);
-  if (requireChecksum && !expected) {
-    throw new Error(`Integrity metadata missing for agent payload: ${agentId}`);
-  }
-
-  const digest = crypto.createHash('sha256').update(String(content || ''), 'utf8').digest('hex');
-  if (expected && expected !== digest) {
-    throw new Error(`Integrity check failed for agent payload: ${agentId}`);
-  }
-
-  return {
-    algorithm: 'sha256',
-    checksum: `sha256:${digest}`,
-    expected: expected ? `sha256:${expected}` : null,
-    verified: !!expected
-  };
-}
-
-/**
- * Fetch agent context from API (thin client model)
- * Agent context is not bundled locally - must be fetched from API
- * @param {string} agentId - Agent ID
- * @returns {Promise<{context: string, name: string}|null>}
- */
-async function fetchAgentContext(agentId) {
-  if (!auth.isAuthenticated()) {
-    return null;
-  }
-
-  try {
-    const response = await api.getAgentContext(agentId);
-    const responseTier = String(response?.tier || AGENT_TIERS[agentId] || 'free').toLowerCase();
-    const requiredTier = AGENT_TIERS[agentId] || (responseTier === 'pro' || responseTier === 'premium' ? 'pro' : 'free');
-    if (requiredTier !== 'free' && !tierEnforcement.meetsTierRequirement(requiredTier, auth.getTier())) {
-      return { error: 'upgrade_required', requiredTier };
-    }
-
-    const integrity = verifyPayloadIntegrity(agentId, response?.context || '', 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) {
-      // Tier not sufficient - will be handled by canAccessAgent
-      return { error: 'upgrade_required', requiredTier: error.requiredTier };
-    }
-    if (error.status === 401) {
-      return { error: 'auth_required' };
-    }
-    // Network error or other issue
-    return null;
-  }
-}
-
-async function fetchHostedAgentCatalog() {
-  if (!auth.isAuthenticated()) {
-    return null;
-  }
-
-  try {
-    const response = await api.listAgents();
-    return response.agents || null;
-  } catch {
-    return null;
-  }
-}
-
-async function resolveAgentDefinition(agentId) {
-  if (auth.isAuthenticated()) {
-    try {
-      const response = await api.getAgent(agentId);
-      return response.agent || response;
-    } catch {
-      // Fall back to bundled metadata for discovery.
-    }
-  }
-
-  return AGENTS[agentId] || null;
-}
-
-// Agent definitions - these will be loaded from agents/profiles/ in production
-const AGENTS = {
-  'database-expert': {
-    name: 'Database Expert',
-    category: 'Backend',
-    description: 'Specializes in database design, queries, migrations, and optimization',
-    expertise: ['SQL', 'NoSQL', 'Prisma', 'Drizzle', 'PostgreSQL', 'MongoDB'],
-    triggers: ['database', 'schema', 'migration', 'query', 'prisma', 'sql']
-  },
-  'security-expert': {
-    name: 'Security Expert',
-    category: 'Security',
-    description: 'Focuses on application security, OWASP, authentication, and authorization',
-    expertise: ['OWASP', 'Authentication', 'Authorization', 'Input Validation', 'XSS', 'CSRF'],
-    triggers: ['security', 'auth', 'owasp', 'vulnerability', 'xss', 'csrf', 'injection']
-  },
-  'frontend-expert': {
-    name: 'Frontend Expert',
-    category: 'Frontend',
-    description: 'Expert in React, Next.js, UI components, and modern frontend patterns',
-    expertise: ['React', 'Next.js', 'TypeScript', 'Tailwind', 'Components', 'State Management'],
-    triggers: ['component', 'react', 'frontend', 'ui', 'tailwind', 'css', 'styling']
-  },
-  'backend-expert': {
-    name: 'Backend Expert',
-    category: 'Backend',
-    description: 'Specializes in server-side development, APIs, and business logic',
-    expertise: ['Node.js', 'APIs', 'Server Actions', 'Middleware', 'Business Logic'],
-    triggers: ['api', 'backend', 'server', 'endpoint', 'route', 'middleware']
-  },
-  'api-expert': {
-    name: 'API Expert',
-    category: 'Backend',
-    description: 'Focuses on API design, REST, GraphQL, and integration patterns',
-    expertise: ['REST', 'GraphQL', 'tRPC', 'OpenAPI', 'Webhooks', 'Integration'],
-    triggers: ['api', 'rest', 'graphql', 'trpc', 'webhook', 'endpoint']
-  },
-  'testing-expert': {
-    name: 'Testing Expert',
-    category: 'Quality',
-    description: 'Expert in testing strategies, test frameworks, and quality assurance',
-    expertise: ['Unit Testing', 'Integration Testing', 'E2E', 'Vitest', 'Jest', 'Playwright'],
-    triggers: ['test', 'testing', 'jest', 'vitest', 'playwright', 'coverage']
-  },
-  'performance-expert': {
-    name: 'Performance Expert',
-    category: 'DevOps',
-    description: 'Specializes in performance optimization, caching, and monitoring',
-    expertise: ['Optimization', 'Caching', 'Profiling', 'Core Web Vitals', 'Load Testing'],
-    triggers: ['performance', 'optimize', 'cache', 'slow', 'speed', 'profiling']
-  },
-  'devops-expert': {
-    name: 'DevOps Expert',
-    category: 'DevOps',
-    description: 'Focuses on deployment, CI/CD, infrastructure, and monitoring',
-    expertise: ['CI/CD', 'Docker', 'Kubernetes', 'Monitoring', 'Infrastructure'],
-    triggers: ['deploy', 'ci', 'cd', 'docker', 'kubernetes', 'infrastructure']
-  },
-  'ui-ux-expert': {
-    name: 'UI/UX Expert',
-    category: 'Frontend',
-    description: 'Expert in user interface design, user experience, and accessibility',
-    expertise: ['Design Systems', 'Accessibility', 'Responsive Design', 'Animation'],
-    triggers: ['ui', 'ux', 'design', 'accessibility', 'a11y', 'responsive']
-  },
-  'architecture-expert': {
-    name: 'Architecture Expert',
-    category: 'Backend',
-    description: 'Specializes in system architecture, design patterns, and scalability',
-    expertise: ['System Design', 'Design Patterns', 'Microservices', 'Scalability'],
-    triggers: ['architecture', 'design', 'pattern', 'scalability', 'structure']
-  },
-  'code-review-expert': {
-    name: 'Code Review Expert',
-    category: 'Quality',
-    description: 'Focuses on code quality, best practices, and constructive feedback',
-    expertise: ['Code Quality', 'Best Practices', 'Refactoring', 'Clean Code'],
-    triggers: ['review', 'refactor', 'quality', 'clean', 'improve']
-  },
-  'vercel-expert': {
-    name: 'Vercel Expert',
-    category: 'DevOps',
-    description: 'Expert in Vercel deployment, serverless, and edge functions',
-    expertise: ['Vercel', 'Serverless', 'Edge Functions', 'ISR', 'Deployment'],
-    triggers: ['vercel', 'serverless', 'edge', 'deployment', 'hosting']
-  },
-  // Business Agents
-  'business-strategy-expert': {
-    name: 'Business Strategy Expert',
-    category: 'Business',
-    description: 'Specializes in business model design, market analysis, and strategic planning',
-    expertise: ['Business Models', 'Market Analysis', 'Competitive Strategy', 'Go-to-Market', 'Unit Economics'],
-    triggers: ['business', 'strategy', 'market', 'model', 'gtm', 'positioning']
-  },
-  'financial-expert': {
-    name: 'Financial Expert',
-    category: 'Business',
-    description: 'Expert in financial modeling, projections, and startup finance',
-    expertise: ['Financial Modeling', 'Revenue Projections', 'Unit Economics', 'Cash Flow', 'Budgeting'],
-    triggers: ['financial', 'finance', 'revenue', 'projection', 'budget', 'cash', 'model']
-  },
-  'fundraising-expert': {
-    name: 'Fundraising Expert',
-    category: 'Business',
-    description: 'Specializes in investor relations, pitch decks, and fundraising strategy',
-    expertise: ['Pitch Decks', 'Investor Relations', 'Term Sheets', 'Due Diligence', 'Fundraising Strategy'],
-    triggers: ['fundraise', 'investor', 'pitch', 'deck', 'seed', 'series', 'vc', 'angel']
-  },
-  'private-equity-expert': {
-    name: 'Private Equity Expert',
-    category: 'Business',
-    description: 'Expert in PE/VC dynamics, valuation, and deal structuring',
-    expertise: ['Valuation', 'Deal Structure', 'Cap Tables', 'Term Sheets', 'Exit Strategy'],
-    triggers: ['pe', 'equity', 'valuation', 'cap table', 'term sheet', 'dilution']
-  },
-  'investor-relations-expert': {
-    name: 'Investor Relations Expert',
-    category: 'Business',
-    description: 'Specializes in investor communications, reporting, and stakeholder management',
-    expertise: ['Investor Updates', 'Board Management', 'KPI Reporting', 'Stakeholder Communication'],
-    triggers: ['investor', 'board', 'update', 'reporting', 'stakeholder']
-  },
-  'legal-expert': {
-    name: 'Legal Expert',
-    category: 'Business',
-    description: 'Expert in startup legal matters, contracts, and compliance',
-    expertise: ['Terms of Service', 'Privacy Policy', 'Contracts', 'IP', 'Compliance', 'GDPR'],
-    triggers: ['legal', 'terms', 'privacy', 'contract', 'compliance', 'gdpr', 'ip']
-  },
-  'marketing-expert': {
-    name: 'Marketing Expert',
-    category: 'Business',
-    description: 'Specializes in digital marketing, content strategy, and brand building',
-    expertise: ['Content Marketing', 'SEO', 'Social Media', 'Email Marketing', 'Brand Strategy'],
-    triggers: ['marketing', 'content', 'seo', 'social', 'brand', 'campaign']
-  },
-  'sales-expert': {
-    name: 'Sales Expert',
-    category: 'Business',
-    description: 'Expert in sales strategy, pipeline management, and customer acquisition',
-    expertise: ['Sales Strategy', 'Pipeline Management', 'CRM', 'Lead Generation', 'Closing'],
-    triggers: ['sales', 'pipeline', 'lead', 'crm', 'close', 'deal', 'prospect']
-  },
-  'growth-expert': {
-    name: 'Growth Expert',
-    category: 'Business',
-    description: 'Specializes in growth hacking, metrics, and user acquisition',
-    expertise: ['Growth Hacking', 'User Acquisition', 'Retention', 'Viral Loops', 'A/B Testing'],
-    triggers: ['growth', 'acquisition', 'retention', 'viral', 'metrics', 'experiment']
-  },
-  'operations-expert': {
-    name: 'Operations Expert',
-    category: 'Business',
-    description: 'Expert in operational efficiency, processes, and team management',
-    expertise: ['Process Design', 'Team Management', 'Hiring', 'OKRs', 'Operational Efficiency'],
-    triggers: ['operations', 'ops', 'process', 'team', 'hiring', 'okr', 'efficiency']
-  },
-  'competitive-analysis-expert': {
-    name: 'Competitive Analysis Expert',
-    category: 'Business',
-    description: 'Specializes in market research, competitor analysis, and positioning',
-    expertise: ['Competitor Analysis', 'Market Research', 'SWOT', 'Positioning', 'Differentiation'],
-    triggers: ['competitive', 'competitor', 'analysis', 'market', 'swot', 'positioning']
-  },
-  'partnerships-expert': {
-    name: 'Partnerships Expert',
-    category: 'Business',
-    description: 'Expert in partnership development, BD, and strategic alliances',
-    expertise: ['Partnership Development', 'Business Development', 'Strategic Alliances', 'Channel Partners'],
-    triggers: ['partnership', 'partner', 'bd', 'alliance', 'channel', 'integration']
-  },
-  // DevOps Agents
-  'railway-expert': {
-    name: 'Railway Expert',
-    category: 'DevOps',
-    description: 'Expert in Railway deployment, databases, and infrastructure',
-    expertise: ['Railway', 'PostgreSQL', 'Redis', 'Deployment', 'Scaling'],
-    triggers: ['railway', 'deploy', 'postgres', 'redis', 'infrastructure']
-  },
-  'monitoring-expert': {
-    name: 'Monitoring Expert',
-    category: 'DevOps',
-    description: 'Specializes in observability, logging, metrics, and alerting',
-    expertise: ['Observability', 'Logging', 'Metrics', 'Alerting', 'APM', 'Sentry', 'Datadog'],
-    triggers: ['monitoring', 'logging', 'metrics', 'alerts', 'observability', 'sentry']
-  },
-  // Research Agents
-  'research-expert': {
-    name: 'Research Expert',
-    category: 'Research',
-    description: 'Expert in market research, user research, and data analysis',
-    expertise: ['Market Research', 'User Research', 'Surveys', 'Interviews', 'Data Analysis'],
-    triggers: ['research', 'survey', 'interview', 'user research', 'market research']
-  },
-  'data-modeling-expert': {
-    name: 'Data Modeling Expert',
-    category: 'Research',
-    description: 'Specializes in data architecture, ERD design, and schema optimization',
-    expertise: ['ERD Design', 'Schema Design', 'Normalization', 'Indexing', 'Data Architecture'],
-    triggers: ['data model', 'erd', 'schema', 'entity', 'relationship', 'normalization']
-  },
-  // Integration Agents
-  'payment-expert': {
-    name: 'Payment Expert',
-    category: 'Integration',
-    description: 'Expert in payment processing, Stripe integration, and subscription billing',
-    expertise: ['Stripe', 'Subscriptions', 'Billing', 'Webhooks', 'Checkout', 'Payment Processing'],
-    triggers: ['payment', 'stripe', 'subscription', 'billing', 'checkout', 'invoice']
-  },
-  'ai-integration-expert': {
-    name: 'AI Integration Expert',
-    category: 'Integration',
-    description: 'Specializes in AI/LLM integration, Anthropic Claude, and AI SDK',
-    expertise: ['Claude API', 'AI SDK', 'Streaming', 'Tool Use', 'RAG', 'Embeddings'],
-    triggers: ['ai', 'llm', 'claude', 'anthropic', 'openai', 'streaming', 'embedding']
-  },
-  'email-expert': {
-    name: 'Email Expert',
-    category: 'Integration',
-    description: 'Expert in email integration, Resend, and transactional emails',
-    expertise: ['Resend', 'React Email', 'Transactional Email', 'Templates', 'Email Delivery'],
-    triggers: ['email', 'resend', 'sendgrid', 'template', 'notification', 'transactional']
-  },
-  'auth-expert': {
-    name: 'Auth Expert',
-    category: 'Integration',
-    description: 'Specializes in authentication, Clerk, NextAuth, and session management',
-    expertise: ['Clerk', 'NextAuth', 'OAuth', 'JWT', 'Session Management', 'RBAC'],
-    triggers: ['auth', 'authentication', 'login', 'session', 'oauth', 'clerk', 'nextauth']
-  },
-  // Content Agents
-  'content-expert': {
-    name: 'Content Expert',
-    category: 'Content',
-    description: 'Expert in technical writing, documentation, blogs, marketing copy, and content strategy',
-    expertise: ['Technical Writing', 'Documentation', 'Blog Posts', 'Release Notes', 'README', 'API Docs', 'SEO', 'Content Strategy'],
-    triggers: ['content', 'writing', 'documentation', 'docs', 'blog', 'readme', 'changelog', 'copy', 'article', 'marketing']
-  },
-  // Product Agents
-  'product-expert': {
-    name: 'Product Expert',
-    category: 'Product',
-    description: 'Expert in product management, roadmapping, feature prioritization, and user research',
-    expertise: ['Product Strategy', 'Roadmapping', 'Feature Prioritization', 'User Research', 'PRDs', 'OKRs', 'Metrics', 'Product-Market Fit'],
-    triggers: ['product', 'roadmap', 'feature', 'prioritization', 'prd', 'requirements', 'user research', 'okr', 'metrics', 'backlog']
-  },
-  // Mobile Agents
-  'mobile-expert': {
-    name: 'Mobile Expert',
-    category: 'Mobile',
-    description: 'Expert in mobile development with React Native, Flutter, iOS, and Android',
-    expertise: ['React Native', 'Flutter', 'iOS', 'Android', 'Mobile Architecture', 'App Store', 'Push Notifications', 'Offline-First'],
-    triggers: ['mobile', 'react native', 'flutter', 'ios', 'android', 'app', 'native', 'swift', 'kotlin', 'expo']
-  },
-  // Infrastructure Agents
-  'infrastructure-expert': {
-    name: 'Infrastructure Expert',
-    category: 'DevOps',
-    description: 'Expert in cloud infrastructure, Terraform, Kubernetes, and DevOps practices',
-    expertise: ['AWS', 'GCP', 'Azure', 'Terraform', 'Kubernetes', 'Docker', 'CI/CD', 'Infrastructure-as-Code', 'Cloud Architecture'],
-    triggers: ['infrastructure', 'cloud', 'aws', 'gcp', 'terraform', 'kubernetes', 'k8s', 'docker', 'devops', 'iac']
-  }
-};
-
-/**
- * List all available agents
- */
-async function listAgents() {
-  const userTier = tierEnforcement.getTier();
-  const hostedAgents = await fetchHostedAgentCatalog();
-
-  console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Agents${utils.COLORS.reset}
-${utils.COLORS.dim}Specialized AI expertise on demand${utils.COLORS.reset}
-${utils.COLORS.dim}Your tier: ${userTier}${utils.COLORS.reset}
-`);
-
-  const catalog = Array.isArray(hostedAgents) && hostedAgents.length > 0
-    ? hostedAgents.map((agent) => ({
-      id: agent.id,
-      name: agent.name,
-      category: agent.category || 'Hosted',
-      description: agent.description,
-      expertise: agent.expertise || [],
-      accessible: agent.accessible,
-      requiredTier: agent.requiredTier || AGENT_TIERS[agent.id] || 'free'
-    }))
-    : Object.entries(AGENTS).map(([id, agent]) => ({
-      id,
-      ...agent,
-      accessible: canAccessAgent(id).allowed,
-      requiredTier: AGENT_TIERS[id] || 'free'
-    }));
-
-  const categories = {};
-  for (const agent of catalog) {
-    if (!categories[agent.category]) {
-      categories[agent.category] = [];
-    }
-    categories[agent.category].push(agent);
-  }
-
-  let accessibleCount = 0;
-  let lockedCount = 0;
-
-  for (const [category, agents] of Object.entries(categories)) {
-    console.log(`${utils.COLORS.bold}${category}${utils.COLORS.reset}`);
-    for (const agent of agents) {
-      const accessible = agent.accessible !== false;
-      const requiredTier = agent.requiredTier || AGENT_TIERS[agent.id];
-      const tierBadge = requiredTier && requiredTier !== 'free'
-        ? ` ${utils.COLORS.yellow}[${requiredTier}]${utils.COLORS.reset}`
-        : '';
-      const lockIcon = accessible ? '' : ` ${utils.COLORS.red}🔒${utils.COLORS.reset}`;
-
-      if (accessible) {
-        accessibleCount++;
-      } else {
-        lockedCount++;
-      }
-
-      console.log(`  ${utils.COLORS.cyan}${agent.id}${utils.COLORS.reset}${tierBadge}${lockIcon}`);
-      console.log(`    ${utils.COLORS.dim}${agent.description}${utils.COLORS.reset}`);
-    }
-    console.log();
-  }
-
-  utils.print.dim(`${accessibleCount} agents available, ${lockedCount} locked`);
-  utils.print.dim('Use "bootspring agent show <name>" for details');
-}
-
-/**
- * Show agent details
- */
-async function showAgent(agentId) {
-  const agent = await resolveAgentDefinition(agentId);
-
-  if (!agent) {
-    utils.print.error(`Agent not found: ${agentId}`);
-    utils.print.dim('Use "bootspring agent list" to see available agents');
-    return;
-  }
-
-  const expertise = Array.isArray(agent.expertise) ? agent.expertise : [];
-  const triggers = Array.isArray(agent.triggers) ? agent.triggers : [];
-
-  console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}⚡ ${agent.name}${utils.COLORS.reset}
-${utils.COLORS.dim}Category: ${agent.category || 'Hosted'}${utils.COLORS.reset}
-
-${utils.COLORS.bold}Description${utils.COLORS.reset}
-${agent.description}
-
-${utils.COLORS.bold}Expertise${utils.COLORS.reset}
-${expertise.length > 0 ? expertise.map(e => `  ${utils.COLORS.green}●${utils.COLORS.reset} ${e}`).join('\n') : `  ${utils.COLORS.dim}Hosted agent expertise${utils.COLORS.reset}`}
-
-${utils.COLORS.bold}Trigger Keywords${utils.COLORS.reset}
-${triggers.length > 0 ? triggers.map(t => `  ${utils.COLORS.dim}${t}${utils.COLORS.reset}`).join(', ') : `  ${utils.COLORS.dim}Server-managed${utils.COLORS.reset}`}
-
-${utils.COLORS.bold}Usage${utils.COLORS.reset}
-  bootspring agent invoke ${agentId} --topic "your question"
-`);
-}
-
-/**
- * Invoke an agent
- */
-async function invokeAgent(agentId, args) {
-  const agent = await resolveAgentDefinition(agentId);
-
-  if (!agent) {
-    utils.print.error(`Agent not found: ${agentId}`);
-    utils.print.dim('Use "bootspring agent list" to see available agents');
-    return;
-  }
-
-  // Check authentication first
-  if (!auth.isAuthenticated()) {
-    console.log(`
-${utils.COLORS.yellow}${utils.COLORS.bold}⚡ ${agent.name}${utils.COLORS.reset}
-${utils.COLORS.red}Authentication required${utils.COLORS.reset}
-
-${utils.COLORS.dim}Agent context is served from the API. Please log in:${utils.COLORS.reset}
-  ${utils.COLORS.cyan}bootspring auth login${utils.COLORS.reset}
-`);
-    return;
-  }
-
-  // Check tier access (client-side check for UX, server enforces)
-  const access = canAccessAgent(agentId);
-  if (!access.allowed) {
-    const promptContext = trackUpgradePrompted(agentId, access.requiredTier || 'pro');
-    console.log(`
-${utils.COLORS.yellow}${utils.COLORS.bold}⚡ ${agent.name}${utils.COLORS.reset}
-${utils.COLORS.red}This agent requires ${access.requiredTier} tier or higher.${utils.COLORS.reset}
-`);
-    console.log(tierEnforcement.getUpgradePrompt(`agent: ${agentId}`, access.requiredTier || 'pro', {
-      capability: promptContext.capability,
-      action: promptContext.action,
-      placement: promptContext.placement,
-      variant: promptContext.variant
-    }));
-    return;
-  }
-
-  const isMCP = utils.isMCPContext();
-  const parsedArgs = utils.parseArgs(args);
-  const topic = parsedArgs.topic || args.filter(a => !a.startsWith('--')).join(' ');
-
-  // Track agent invocation
-  trackAgentInvocation(agentId, topic);
-
-  console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}⚡ ${agent.name}${utils.COLORS.reset}
-${utils.COLORS.dim}${agent.description}${utils.COLORS.reset}
-`);
-
-  // Fetch agent context from API (thin client - no local content)
-  const spinner = utils.createSpinner('Loading agent context...');
-  spinner.start();
-
-  const contextResult = await fetchAgentContext(agentId);
-
-  if (!contextResult) {
-    spinner.fail('Failed to load agent context');
-    console.log(`${utils.COLORS.dim}Check your internet connection and try again.${utils.COLORS.reset}`);
-    return;
-  }
-
-  if (contextResult.error === 'upgrade_required') {
-    const promptContext = trackUpgradePrompted(agentId, contextResult.requiredTier || 'pro');
-    spinner.fail('Upgrade required');
-    console.log(tierEnforcement.getUpgradePrompt(`agent: ${agentId}`, contextResult.requiredTier || 'pro', {
-      capability: promptContext.capability,
-      action: promptContext.action,
-      placement: promptContext.placement,
-      variant: promptContext.variant
-    }));
-    return;
-  }
-
-  if (contextResult.error === 'auth_required') {
-    spinner.fail('Authentication required');
-    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
-    return;
-  }
-
-  if (contextResult.error === 'integrity_error') {
-    spinner.fail('Integrity verification failed');
-    console.log(`${utils.COLORS.dim}${contextResult.message || 'Agent payload checksum mismatch.'}${utils.COLORS.reset}`);
-    return;
-  }
-
-  spinner.succeed('Agent context loaded');
-  const responseTier = String(contextResult.tier || AGENT_TIERS[agentId] || 'free').toLowerCase();
-  const requiredTier = AGENT_TIERS[agentId] || (responseTier === 'pro' || responseTier === 'premium' ? 'pro' : 'free');
-  if (requiredTier !== 'free') {
-    trackUpgradeUnlocked(agentId, requiredTier);
-  }
-
-  // In MCP mode, output the context for the AI to use
-  if (isMCP) {
-    console.log(`\n${utils.COLORS.bold}Agent Context:${utils.COLORS.reset}\n`);
-    console.log(contextResult.context);
-    return;
-  }
-
-  // CLI mode - show context and guidance
-  console.log(`\n${utils.COLORS.bold}Agent Context:${utils.COLORS.reset}`);
-  console.log(`${utils.COLORS.dim}─────────────────────────────────────${utils.COLORS.reset}`);
-
-  // Show truncated context in CLI mode
-  const contextLines = contextResult.context.split('\n');
-  const previewLines = contextLines.slice(0, 20);
-  console.log(previewLines.join('\n'));
-
-  if (contextLines.length > 20) {
-    console.log(`\n${utils.COLORS.dim}... (${contextLines.length - 20} more lines)${utils.COLORS.reset}`);
-  }
-
-  console.log(`${utils.COLORS.dim}─────────────────────────────────────${utils.COLORS.reset}`);
-
-  if (topic) {
-    console.log(`\n${utils.COLORS.bold}Your topic:${utils.COLORS.reset} "${topic}"
-${utils.COLORS.dim}Use this context with your AI assistant for the topic above.${utils.COLORS.reset}
-`);
-  }
-
-  console.log(`
-${utils.COLORS.bold}Usage:${utils.COLORS.reset}
-  Copy the context above and use it with your AI assistant.
-
-${utils.COLORS.yellow}${utils.COLORS.bold}Enhanced Mode${utils.COLORS.reset}
-${utils.COLORS.dim}With MCP integration, agents activate automatically.${utils.COLORS.reset}
-  ${utils.COLORS.cyan}bootspring mcp start${utils.COLORS.reset}
-`);
-}
-
-/**
- * Search for agents by keyword
- */
-async function searchAgents(query) {
-  const hostedAgents = await fetchHostedAgentCatalog();
-  const queryLower = query.toLowerCase();
-
-  const catalog = Array.isArray(hostedAgents) && hostedAgents.length > 0
-    ? hostedAgents.map((agent) => [agent.id, {
-      name: agent.name,
-      description: agent.description,
-      expertise: agent.expertise || [],
-      triggers: agent.triggers || []
-    }])
-    : Object.entries(AGENTS);
-
-  const matches = catalog.filter(([id, agent]) => (
-    id.includes(queryLower) ||
-    agent.name.toLowerCase().includes(queryLower) ||
-    agent.description.toLowerCase().includes(queryLower) ||
-    agent.expertise.some(e => e.toLowerCase().includes(queryLower)) ||
-    agent.triggers.some(t => t.includes(queryLower))
-  ));
-
-  if (matches.length === 0) {
-    utils.print.warning(`No agents found matching "${query}"`);
-    utils.print.dim('Use "bootspring agent list" to see all agents');
-    return;
-  }
-
-  console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Agent Search: "${query}"${utils.COLORS.reset}
-`);
-
-  for (const [id, agent] of matches) {
-    console.log(`  ${utils.COLORS.cyan}${id}${utils.COLORS.reset} - ${agent.description}`);
-  }
-
-  console.log();
-  utils.print.dim(`${matches.length} agents found`);
-}
-
-/**
- * Show agent help
- */
-function showHelp() {
-  console.log(`
-${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Agent${utils.COLORS.reset}
-${utils.COLORS.dim}Work with specialized AI agents${utils.COLORS.reset}
-
-${utils.COLORS.bold}Usage:${utils.COLORS.reset}
-  bootspring agent <command> [args]
-
-${utils.COLORS.bold}Commands:${utils.COLORS.reset}
-  ${utils.COLORS.cyan}list${utils.COLORS.reset}              List all available agents
-  ${utils.COLORS.cyan}show${utils.COLORS.reset} <name>       Show agent details
-  ${utils.COLORS.cyan}invoke${utils.COLORS.reset} <name>     Invoke an agent
-  ${utils.COLORS.cyan}search${utils.COLORS.reset} <query>    Search for agents
-
-${utils.COLORS.bold}Examples:${utils.COLORS.reset}
-  bootspring agent list
-  bootspring agent show security-expert
-  bootspring agent invoke database-expert --topic "optimize queries"
-  bootspring agent search performance
-`);
-}
-
-/**
- * Run agent command
- */
-async function run(args) {
-  const subcommand = args[0] || 'list';
-  const subargs = args.slice(1);
-
-  switch (subcommand) {
-    case 'list':
-    case 'ls':
-      await listAgents();
-      break;
-
-    case 'show':
-    case 'info':
-      if (!subargs[0]) {
-        utils.print.error('Please specify an agent name');
-        utils.print.dim('Usage: bootspring agent show <name>');
-        return;
-      }
-      await showAgent(subargs[0]);
-      break;
-
-    case 'invoke':
-    case 'use':
-    case 'call':
-      if (!subargs[0]) {
-        utils.print.error('Please specify an agent name');
-        utils.print.dim('Usage: bootspring agent invoke <name> --topic "your question"');
-        return;
-      }
-      await invokeAgent(subargs[0], subargs.slice(1));
-      break;
-
-    case 'search':
-    case 'find':
-      if (!subargs[0]) {
-        utils.print.error('Please specify a search query');
-        utils.print.dim('Usage: bootspring agent search <query>');
-        return;
-      }
-      await searchAgents(subargs.join(' '));
-      break;
-
-    case 'help':
-    case '-h':
-    case '--help':
-      showHelp();
-      break;
-
-    default:
-      // Check if it's an agent name (shortcut for show)
-      if (AGENTS[subcommand]) {
-        await showAgent(subcommand);
-      } else {
-        utils.print.error(`Unknown subcommand: ${subcommand}`);
-        showHelp();
-      }
-  }
-}
-
-module.exports = { run, AGENTS, listAgents, showAgent, invokeAgent, searchAgents };