@vibecheckai/cli 3.5.0 → 3.5.2

package/mcp-server/registry/tool-registry.js

@@ -0,0 +1,794 @@
+/**
+ * Single Source of Truth for MCP Tool Registry
+ * 
+ * Defines all MCP tools with:
+ * - Input/output schemas (JSON Schema)
+ * - Tier requirements (free/pro)
+ * - Timeouts
+ * - Rate limits
+ * - Option-level gates
+ * 
+ * This registry is used for:
+ * - Input validation
+ * - Output validation (warnings)
+ * - Tier enforcement
+ * - Timeout configuration
+ * - Rate limit configuration
+ */
+
+const Ajv = require('ajv');
+const ajv = new Ajv({ allErrors: true, strict: false });
+
+// Note: Tool tier definitions are defined here in TOOL_REGISTRY
+// This is the single source of truth - tier-auth.js references this for consistency
+
+/**
+ * Tool Definition Schema
+ * @typedef {Object} ToolDefinition
+ * @property {string} name - Tool name
+ * @property {string} description - Tool description
+ * @property {'free'|'pro'} tier - Required tier
+ * @property {string} category - Tool category
+ * @property {object} inputSchema - JSON Schema for input validation
+ * @property {object} outputSchema - JSON Schema for output validation (optional)
+ * @property {Array<{name: string, tier?: 'pro', description: string}>} options - Option-level gates
+ * @property {{perMinute: number, perHour?: number}} rateLimit - Rate limit override (optional)
+ * @property {number} timeout - Timeout in milliseconds
+ */
+
+/**
+ * Tool Registry - Single Source of Truth
+ */
+const TOOL_REGISTRY = {
+  // ═══════════════════════════════════════════════════════════════════════════
+  // FREE TOOLS
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.scan': {
+    name: 'vibecheck.scan',
+    description: 'Scan codebase for issues (routes, env, auth, security)',
+    tier: 'free',
+    category: 'analysis',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Project path' },
+        categories: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Categories: routes, env, auth, billing, security',
+        },
+        since: {
+          type: 'string',
+          description: 'ISO timestamp for incremental scan',
+        },
+        noCache: { type: 'boolean', default: false },
+      },
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        findings: { type: 'array' },
+        summary: { type: 'object' },
+        cacheStats: { type: 'object' },
+      },
+    },
+    options: [
+      { name: 'autofix', tier: 'pro', description: 'Auto-fix issues' },
+      { name: 'fix', tier: 'pro', description: 'Fix mode' },
+    ],
+    rateLimit: { perMinute: 10 },
+    timeout: 300000, // 5 min
+  },
+  
+  'vibecheck.ctx': {
+    name: 'vibecheck.ctx',
+    description: 'Generate truth context for AI agents',
+    tier: 'free',
+    category: 'context',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string' },
+        scope: {
+          type: 'string',
+          enum: ['all', 'routes', 'env', 'auth', 'billing'],
+          default: 'all',
+        },
+      },
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        context: { type: 'object' },
+      },
+    },
+    timeout: 120000, // 2 min
+  },
+  
+  'vibecheck.verify': {
+    name: 'vibecheck.verify',
+    description: 'Verify AI-generated code before applying',
+    tier: 'free',
+    category: 'validation',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'Code to verify' },
+        file: { type: 'string' },
+        projectPath: { type: 'string' },
+      },
+      required: ['code'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        verified: { type: 'boolean' },
+        issues: { type: 'array' },
+      },
+    },
+    timeout: 60000, // 1 min
+  },
+  
+  'vibecheck.report': {
+    name: 'vibecheck.report',
+    description: 'Generate reports',
+    tier: 'free',
+    category: 'reporting',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string' },
+        format: { type: 'string', enum: ['html', 'md', 'sarif', 'json'], default: 'html' },
+      },
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        report: { type: 'string' },
+      },
+    },
+    timeout: 120000, // 2 min
+  },
+  
+  'vibecheck.status': {
+    name: 'vibecheck.status',
+    description: 'Check vibecheck status and health',
+    tier: 'free',
+    category: 'diagnostics',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string' },
+      },
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        status: { type: 'object' },
+      },
+    },
+    timeout: 30000, // 30s
+  },
+  
+  'vibecheck.doctor': {
+    name: 'vibecheck.doctor',
+    description: 'Diagnose and fix environment issues',
+    tier: 'free',
+    category: 'diagnostics',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string' },
+        fix: { type: 'boolean', default: false },
+        noCache: { type: 'boolean', default: false },
+      },
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        checks: { type: 'array' },
+        cacheStats: { type: 'object' },
+      },
+    },
+    timeout: 60000, // 1 min
+  },
+  
+  'vibecheck.firewall': {
+    name: 'vibecheck.firewall',
+    description: 'Agent Firewall - observe mode (FREE) or enforce mode (PRO)',
+    tier: 'free',
+    category: 'security',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', enum: ['check', 'status', 'log'] },
+        code: { type: 'string' },
+        file: { type: 'string' },
+      },
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        mode: { type: 'string', enum: ['observe', 'enforce'] },
+        checked: { type: 'boolean' },
+        violations: { type: 'array' },
+      },
+    },
+    options: [
+      { name: 'enforce', tier: 'pro', description: 'Enable enforce mode' },
+      { name: 'mode', tier: 'pro', description: 'Set mode to enforce' },
+    ],
+    timeout: 60000, // 1 min
+  },
+  
+  'authority.list': {
+    name: 'authority.list',
+    description: 'List available authorities',
+    tier: 'free',
+    category: 'authority',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        tier: { type: 'string', enum: ['free', 'pro'] },
+      },
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        authorities: { type: 'array' },
+      },
+    },
+    timeout: 30000, // 30s
+  },
+  
+  'authority.classify': {
+    name: 'authority.classify',
+    description: 'Inventory Authority - analyze duplication and legacy code',
+    tier: 'free',
+    category: 'authority',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', default: '.' },
+        includeNear: { type: 'boolean', default: true },
+        format: { type: 'string', enum: ['json', 'table', 'markdown'], default: 'json' },
+      },
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        classification: { type: 'object' },
+      },
+    },
+    timeout: 120000, // 2 min
+  },
+  
+  'vibecheck_conductor_status': {
+    name: 'vibecheck_conductor_status',
+    description: 'Get multi-agent coordination status',
+    tier: 'free',
+    category: 'conductor',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectRoot: { type: 'string' },
+        includeDetails: { type: 'boolean', default: false },
+      },
+      required: ['projectRoot'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        status: { type: 'object' },
+      },
+    },
+    timeout: 30000, // 30s
+  },
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // PRO TOOLS
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.ship': {
+    name: 'vibecheck.ship',
+    description: 'Get ship verdict: SHIP | WARN | BLOCK',
+    tier: 'pro',
+    category: 'verdicts',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string' },
+        strict: { type: 'boolean' },
+        since: { type: 'string' },
+        noCache: { type: 'boolean', default: false },
+      },
+      required: ['projectPath'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        verdict: { type: 'string', enum: ['SHIP', 'WARN', 'BLOCK'] },
+        reasons: { type: 'array' },
+        cacheStats: { type: 'object' },
+      },
+    },
+    rateLimit: { perMinute: 10 },
+    timeout: 300000, // 5 min
+  },
+  
+  'vibecheck.fix': {
+    name: 'vibecheck.fix',
+    description: 'AI-powered fixes with proof',
+    tier: 'pro',
+    category: 'fixes',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string' },
+        mode: { type: 'string', enum: ['plan', 'apply', 'loop'], default: 'plan' },
+        findingIds: { type: 'array', items: { type: 'string' } },
+      },
+      required: ['projectPath'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        plan: { type: 'array' },
+        applied: { type: 'boolean' },
+      },
+    },
+    options: [
+      { name: 'apply', tier: 'pro', description: 'Apply fixes' },
+      { name: 'loop', tier: 'pro', description: 'Loop mode' },
+    ],
+    timeout: 600000, // 10 min
+  },
+  
+  'vibecheck.prove': {
+    name: 'vibecheck.prove',
+    description: 'Full proof loop with runtime verification',
+    tier: 'pro',
+    category: 'proof',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string' },
+        url: { type: 'string' },
+        maxIterations: { type: 'number', default: 5 },
+        recordVideo: { type: 'boolean', default: true },
+      },
+      required: ['projectPath'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        proof: { type: 'object' },
+      },
+    },
+    timeout: 600000, // 10 min
+  },
+  
+  'vibecheck.gate': {
+    name: 'vibecheck.gate',
+    description: 'CI/CD enforcement - fail builds on issues',
+    tier: 'pro',
+    category: 'enforcement',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string' },
+        strict: { type: 'boolean' },
+      },
+      required: ['projectPath'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        passed: { type: 'boolean' },
+      },
+    },
+    timeout: 300000, // 5 min
+  },
+  
+  'vibecheck.badge': {
+    name: 'vibecheck.badge',
+    description: 'Generate ship badge',
+    tier: 'pro',
+    category: 'reporting',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string' },
+        outputPath: { type: 'string' },
+      },
+      required: ['projectPath'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        badge: { type: 'string' },
+      },
+    },
+    timeout: 120000, // 2 min
+  },
+  
+  'vibecheck.reality': {
+    name: 'vibecheck.reality',
+    description: 'Full runtime verification with auth boundary testing',
+    tier: 'pro',
+    category: 'proof',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string' },
+        auth: { type: 'string' },
+        headed: { type: 'boolean' },
+        maxPages: { type: 'number', default: 20 },
+      },
+      required: ['url'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        results: { type: 'array' },
+      },
+    },
+    options: [
+      { name: 'full', tier: 'pro', description: 'Full mode' },
+      { name: 'auth', tier: 'pro', description: 'Auth boundary testing' },
+    ],
+    timeout: 300000, // 5 min
+  },
+  
+  'vibecheck.ai_test': {
+    name: 'vibecheck.ai_test',
+    description: 'AI agent testing - autonomous exploration',
+    tier: 'pro',
+    category: 'testing',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string' },
+        goal: { type: 'string' },
+        maxActions: { type: 'number', default: 50 },
+      },
+      required: ['url'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        testResults: { type: 'array' },
+      },
+    },
+    timeout: 300000, // 5 min
+  },
+  
+  'vibecheck.share': {
+    name: 'vibecheck.share',
+    description: 'Generate PR/review bundle',
+    tier: 'pro',
+    category: 'reporting',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string' },
+        format: { type: 'string', enum: ['github', 'gitlab', 'slack', 'json'], default: 'github' },
+      },
+      required: ['projectPath'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        bundle: { type: 'object' },
+      },
+    },
+    timeout: 120000, // 2 min
+  },
+  
+  'authority.approve': {
+    name: 'authority.approve',
+    description: 'Execute authority & get verdict (PROCEED/STOP/DEFER)',
+    tier: 'pro',
+    category: 'authority',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        authority: { type: 'string' },
+        projectPath: { type: 'string', default: '.' },
+        dryRun: { type: 'boolean', default: false },
+      },
+      required: ['authority'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        verdict: { type: 'string', enum: ['PROCEED', 'STOP', 'DEFER'] },
+        proof: { type: 'object' },
+      },
+    },
+    timeout: 300000, // 5 min
+  },
+  
+  'vibecheck_conductor_register': {
+    name: 'vibecheck_conductor_register',
+    description: 'Register AI agent for multi-agent coordination',
+    tier: 'pro',
+    category: 'conductor',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agentId: { type: 'string' },
+        projectRoot: { type: 'string' },
+        workingFiles: { type: 'array', items: { type: 'string' } },
+      },
+      required: ['agentId', 'projectRoot'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        sessionId: { type: 'string' },
+      },
+    },
+    timeout: 30000, // 30s
+  },
+  
+  'vibecheck_conductor_acquire_lock': {
+    name: 'vibecheck_conductor_acquire_lock',
+    description: 'Acquire lock on file/folder for exclusive access',
+    tier: 'pro',
+    category: 'conductor',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sessionId: { type: 'string' },
+        path: { type: 'string' },
+        type: { type: 'string', enum: ['exclusive', 'shared'], default: 'exclusive' },
+        reason: { type: 'string' },
+      },
+      required: ['sessionId', 'path'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        lockId: { type: 'string' },
+      },
+    },
+    timeout: 30000, // 30s
+  },
+  
+  'vibecheck_conductor_release_lock': {
+    name: 'vibecheck_conductor_release_lock',
+    description: 'Release a previously acquired lock',
+    tier: 'pro',
+    category: 'conductor',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        lockId: { type: 'string' },
+        sessionId: { type: 'string' },
+      },
+      required: ['lockId', 'sessionId'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+      },
+    },
+    timeout: 30000, // 30s
+  },
+  
+  'vibecheck_conductor_propose': {
+    name: 'vibecheck_conductor_propose',
+    description: 'Submit change proposal for multi-agent coordination',
+    tier: 'pro',
+    category: 'conductor',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sessionId: { type: 'string' },
+        proposalId: { type: 'string' },
+        intent: { type: 'string' },
+        operations: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              type: { type: 'string', enum: ['create', 'modify', 'delete', 'move'] },
+              path: { type: 'string' },
+              content: { type: 'string' },
+            },
+          },
+        },
+        projectRoot: { type: 'string' },
+      },
+      required: ['sessionId', 'proposalId', 'intent', 'operations', 'projectRoot'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+        approved: { type: 'boolean' },
+      },
+    },
+    timeout: 60000, // 1 min
+  },
+  
+  'vibecheck_conductor_terminate': {
+    name: 'vibecheck_conductor_terminate',
+    description: 'Terminate agent session and release all locks',
+    tier: 'pro',
+    category: 'conductor',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sessionId: { type: 'string' },
+      },
+      required: ['sessionId'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean' },
+      },
+    },
+    timeout: 30000, // 30s
+  },
+  
+  'vibecheck_agent_firewall_intercept': {
+    name: 'vibecheck_agent_firewall_intercept',
+    description: 'Agent Firewall (Sentinel) - ENFORCE MODE',
+    tier: 'pro',
+    category: 'security',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agentId: { type: 'string' },
+        filePath: { type: 'string' },
+        content: { type: 'string' },
+        operation: { type: 'string', enum: ['create', 'modify', 'delete'], default: 'modify' },
+        intent: { type: 'string' },
+        projectRoot: { type: 'string' },
+      },
+      required: ['agentId', 'filePath', 'content'],
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        allowed: { type: 'boolean' },
+        violations: { type: 'array' },
+        proof: { type: 'object' },
+      },
+    },
+    timeout: 120000, // 2 min
+  },
+};
+
+// ============================================================================
+// VALIDATION FUNCTIONS
+// ============================================================================
+
+/**
+ * Validate tool input against JSON Schema
+ * @param {string} toolName - Tool name
+ * @param {unknown} input - Input to validate
+ * @returns {{ valid: boolean, errors?: string[] }}
+ */
+function validateToolInput(toolName, input) {
+  const tool = TOOL_REGISTRY[toolName];
+  if (!tool) {
+    return { valid: false, errors: [`Unknown tool: ${toolName}`] };
+  }
+  
+  const validate = ajv.compile(tool.inputSchema);
+  
+  if (!validate(input)) {
+    return {
+      valid: false,
+      errors: validate.errors?.map((e) => `${e.instancePath || '/'} ${e.message}`) || ['Validation failed'],
+    };
+  }
+  
+  return { valid: true };
+}
+
+/**
+ * Validate tool output against JSON Schema (warns on mismatch, doesn't fail)
+ * @param {string} toolName - Tool name
+ * @param {unknown} output - Output to validate
+ * @returns {{ valid: boolean, errors?: string[] }}
+ */
+function validateToolOutput(toolName, output) {
+  const tool = TOOL_REGISTRY[toolName];
+  if (!tool || !tool.outputSchema) {
+    return { valid: true }; // Unknown tool or no schema, skip validation
+  }
+  
+  const validate = ajv.compile(tool.outputSchema);
+  
+  if (!validate(output)) {
+    // Log warning but don't fail - output validation is advisory
+    console.warn(`[MCP] Tool ${toolName} output validation failed:`, validate.errors);
+    return {
+      valid: false,
+      errors: validate.errors?.map((e) => `${e.instancePath || '/'} ${e.message}`) || ['Validation failed'],
+    };
+  }
+  
+  return { valid: true };
+}
+
+/**
+ * Get tool tier requirement
+ * @param {string} toolName - Tool name
+ * @returns {'free'|'pro'} Tier requirement (defaults to 'pro' for unknown tools)
+ */
+function getToolTier(toolName) {
+  return TOOL_REGISTRY[toolName]?.tier || 'pro'; // Default to PRO for unknown tools
+}
+
+/**
+ * Get tool timeout
+ * @param {string} toolName - Tool name
+ * @returns {number} Timeout in milliseconds (defaults to 30000)
+ */
+function getToolTimeout(toolName) {
+  return TOOL_REGISTRY[toolName]?.timeout || 30000; // Default 30s
+}
+
+/**
+ * Get tool rate limit override (if any)
+ * @param {string} toolName - Tool name
+ * @returns {{perMinute: number, perHour?: number}|null} Rate limit override or null
+ */
+function getToolRateLimit(toolName) {
+  return TOOL_REGISTRY[toolName]?.rateLimit || null;
+}
+
+/**
+ * Get all registered tool names
+ * @returns {string[]} Array of tool names
+ */
+function getAllToolNames() {
+  return Object.keys(TOOL_REGISTRY);
+}
+
+/**
+ * Get tool definition
+ * @param {string} toolName - Tool name
+ * @returns {ToolDefinition|undefined} Tool definition
+ */
+function getToolDefinition(toolName) {
+  return TOOL_REGISTRY[toolName];
+}
+
+module.exports = {
+  TOOL_REGISTRY,
+  validateToolInput,
+  validateToolOutput,
+  getToolTier,
+  getToolTimeout,
+  getToolRateLimit,
+  getAllToolNames,
+  getToolDefinition,
+};