@girardmedia/bootspring 1.2.0 → 2.0.3

package/cli/agent.js

@@ -7,6 +7,55 @@
  */
 
 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
+  }
+}
+
+/**
+ * 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);
+    return response;
+  } catch (error) {
+    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;
+  }
+}
 
 // Agent definitions - these will be loaded from agents/profiles/ in production
 const AGENTS = {
@@ -237,6 +286,38 @@ const AGENTS = {
     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']
   }
 };
 
@@ -244,9 +325,12 @@ const AGENTS = {
  * List all available agents
  */
 function listAgents() {
+  const userTier = tierEnforcement.getTier();
+
   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}
 `);
 
   // Group by category
@@ -258,16 +342,31 @@ ${utils.COLORS.dim}Specialized AI expertise on demand${utils.COLORS.reset}
     categories[agent.category].push({ id, ...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) {
-      console.log(`  ${utils.COLORS.cyan}${agent.id}${utils.COLORS.reset}`);
+      const access = canAccessAgent(agent.id);
+      const tierBadge = AGENT_TIERS[agent.id]
+        ? ` ${utils.COLORS.yellow}[${AGENT_TIERS[agent.id]}]${utils.COLORS.reset}`
+        : '';
+      const lockIcon = access.allowed ? '' : ` ${utils.COLORS.red}🔒${utils.COLORS.reset}`;
+
+      if (access.allowed) {
+        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(`${Object.keys(AGENTS).length} agents available`);
+  utils.print.dim(`${accessibleCount} agents available, ${lockedCount} locked`);
   utils.print.dim('Use "bootspring agent show <name>" for details');
 }
 
@@ -304,7 +403,7 @@ ${utils.COLORS.bold}Usage${utils.COLORS.reset}
 /**
  * Invoke an agent
  */
-function invokeAgent(agentId, _args) {
+async function invokeAgent(agentId, args) {
   const agent = AGENTS[agentId];
 
   if (!agent) {
@@ -313,29 +412,102 @@ function invokeAgent(agentId, _args) {
     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) {
+    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.name, access.requiredTier));
+    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') {
+    spinner.fail('Upgrade required');
+    console.log(tierEnforcement.getUpgradePrompt(agent.name, contextResult.requiredTier || 'pro'));
+    return;
+  }
+
+  if (contextResult.error === 'auth_required') {
+    spinner.fail('Authentication required');
+    console.log(`${utils.COLORS.dim}Run: bootspring auth login${utils.COLORS.reset}`);
+    return;
+  }
+
+  spinner.succeed('Agent context loaded');
+
+  // 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;
+  }
 
-${utils.COLORS.yellow}${utils.COLORS.bold}MCP Integration Required${utils.COLORS.reset}
+  // 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}`);
 
-Agent invocation requires MCP (Model Context Protocol) integration.
-With MCP enabled, agents are automatically invoked based on your prompts.
+  // Show truncated context in CLI mode
+  const contextLines = contextResult.context.split('\n');
+  const previewLines = contextLines.slice(0, 20);
+  console.log(previewLines.join('\n'));
 
-${utils.COLORS.bold}Setup:${utils.COLORS.reset}
-  1. Start the MCP server:
-     ${utils.COLORS.cyan}bootspring mcp start${utils.COLORS.reset}
+  if (contextLines.length > 20) {
+    console.log(`\n${utils.COLORS.dim}... (${contextLines.length - 20} more lines)${utils.COLORS.reset}`);
+  }
 
-  2. Configure your AI client (Claude Code, etc.) to connect to Bootspring MCP
+  console.log(`${utils.COLORS.dim}─────────────────────────────────────${utils.COLORS.reset}`);
 
-  3. Use natural language - agents activate automatically:
-     ${utils.COLORS.dim}"Review my database schema for performance issues"${utils.COLORS.reset}
-     ${utils.COLORS.dim}"Check this code for security vulnerabilities"${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}
+`);
+  }
 
-${utils.COLORS.bold}Documentation:${utils.COLORS.reset}
-  https://bootspring.com/docs/mcp-setup
+  console.log(`
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  Copy the context above and use it with your AI assistant.
 
-${utils.COLORS.dim}Run "bootspring mcp" for MCP server options${utils.COLORS.reset}
+${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}
 `);
 }
 
@@ -427,7 +599,7 @@ async function run(args) {
         utils.print.dim('Usage: bootspring agent invoke <name> --topic "your question"');
         return;
       }
-      invokeAgent(subargs[0], subargs.slice(1));
+      await invokeAgent(subargs[0], subargs.slice(1));
       break;
 
     case 'search':