@vibecheckai/cli 3.0.4 → 3.0.7

package/mcp-server/test-mcp.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * MCP Server Test Script
+ * Tests that all tools are properly registered and can be invoked
+ */
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+console.log('🧪 Testing vibecheck MCP Server...\n');
+
+// Test 1: Import all modules
+async function testImports() {
+  console.log('1️⃣ Testing module imports...');
+  try {
+    const { INTELLIGENCE_TOOLS } = await import('./intelligence-tools.js');
+    const { VIBECHECK_TOOLS } = await import('./vibecheck-tools.js');
+    const { AGENT_CHECKPOINT_TOOLS } = await import('./agent-checkpoint.js');
+    const { ARCHITECT_TOOLS } = await import('./architect-tools.js');
+    const { CODEBASE_ARCHITECT_TOOLS } = await import('./codebase-architect-tools.js');
+    const { VIBECHECK_2_TOOLS } = await import('./vibecheck-2.0-tools.js');
+    const { intentDriftTools } = await import('./intent-drift-tools.js');
+    const { mdcGeneratorTool } = await import('./mdc-generator.js');
+    
+    console.log(`   ✅ Intelligence tools: ${INTELLIGENCE_TOOLS.length}`);
+    console.log(`   ✅ vibecheck tools: ${VIBECHECK_TOOLS.length}`);
+    console.log(`   ✅ Checkpoint tools: ${AGENT_CHECKPOINT_TOOLS.length}`);
+    console.log(`   ✅ Architect tools: ${ARCHITECT_TOOLS.length}`);
+    console.log(`   ✅ Codebase Architect tools: ${CODEBASE_ARCHITECT_TOOLS.length}`);
+    console.log(`   ✅ vibecheck 2.0 tools: ${VIBECHECK_2_TOOLS.length}`);
+    console.log(`   ✅ Intent Drift tools: ${intentDriftTools.length}`);
+    console.log(`   ✅ MDC Generator tool: ${mdcGeneratorTool.name}`);
+    
+    const totalTools = INTELLIGENCE_TOOLS.length + VIBECHECK_TOOLS.length + 
+      AGENT_CHECKPOINT_TOOLS.length + ARCHITECT_TOOLS.length + 
+      CODEBASE_ARCHITECT_TOOLS.length + VIBECHECK_2_TOOLS.length + 
+      intentDriftTools.length + 1;
+    
+    console.log(`\n   📊 Total tools available: ${totalTools}\n`);
+    return true;
+  } catch (error) {
+    console.log(`   ❌ Import failed: ${error.message}`);
+    return false;
+  }
+}
+
+// Test 2: Verify tier auth
+async function testTierAuth() {
+  console.log('2️⃣ Testing tier authentication...');
+  try {
+    const tierAuth = await import('./tier-auth.js');
+    console.log(`   ✅ Tiers available: ${Object.keys(tierAuth.TIERS).join(', ')}`);
+    console.log(`   ✅ Tier auth module loaded successfully`);
+    return true;
+  } catch (error) {
+    console.log(`   ❌ Tier auth failed: ${error.message}`);
+    return false;
+  }
+}
+
+// Test 3: Verify audit trail
+async function testAudit() {
+  console.log('3️⃣ Testing audit trail...');
+  try {
+    const { emitToolInvoke, emitToolComplete } = await import('./audit-mcp.js');
+    console.log(`   ✅ Audit functions available`);
+    return true;
+  } catch (error) {
+    console.log(`   ❌ Audit failed: ${error.message}`);
+    return false;
+  }
+}
+
+// Run all tests
+async function runTests() {
+  const results = [];
+  
+  results.push(await testImports());
+  results.push(await testTierAuth());
+  results.push(await testAudit());
+  
+  console.log('\n' + '='.repeat(50));
+  const passed = results.filter(r => r).length;
+  const total = results.length;
+  
+  if (passed === total) {
+    console.log(`✅ All ${total} tests passed!`);
+    console.log('\n🎉 MCP Server is ready for use!\n');
+    console.log('To use with Claude Desktop, add to claude_desktop_config.json:');
+    console.log(`{
+  "mcpServers": {
+    "vibecheck": {
+      "command": "node",
+      "args": ["${__dirname.replace(/\\/g, '/')}/index.js"]
+    }
+  }
+}`);
+  } else {
+    console.log(`❌ ${total - passed}/${total} tests failed`);
+    process.exit(1);
+  }
+}
+
+runTests().catch(console.error);

package/mcp-server/test-tools.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Test individual MCP tools
+ */
+
+import { VIBECHECK_TOOLS } from './vibecheck-tools.js';
+import { INTELLIGENCE_TOOLS } from './intelligence-tools.js';
+
+console.log('🔧 Testing MCP Server Tools...\n');
+
+// List all available tools
+console.log('Available vibecheck Tools:');
+VIBECHECK_TOOLS.forEach(tool => {
+  console.log(`  - ${tool.name}: ${tool.description}`);
+});
+
+console.log('\nAvailable Intelligence Tools:');
+INTELLIGENCE_TOOLS.forEach(tool => {
+  console.log(`  - ${tool.name}: ${tool.description}`);
+});
+
+// Test a simple tool function
+console.log('\n🧪 Testing tool execution...');
+
+// Test vibecheck.mdc function
+try {
+  const { handleVibecheckTool } = await import('./vibecheck-tools.js');
+  const result = await handleVibecheckTool('vibecheck.mdc', {
+    path: process.cwd(),
+    output: 'test-output.mdc'
+  });
+  console.log('✅ vibecheck.mdc tool executed successfully');
+  console.log('Result:', JSON.stringify(result, null, 2));
+} catch (error) {
+  console.log('❌ Tool execution failed:', error.message);
+}

package/mcp-server/tier-auth.js

@@ -0,0 +1,147 @@
+/**
+ * MCP Server Tier Authentication & Authorization
+ * 
+ * Provides tier checking for MCP tools based on API keys
+ */
+
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+// Tier definitions
+export const TIERS = {
+  free: {
+    name: 'Free',
+    features: ['verify', 'quality', 'hallucination'],
+    limits: { scans: 10, projects: 1 }
+  },
+  starter: {
+    name: 'Starter', 
+    features: ['verify', 'quality', 'hallucination', 'smells', 'breaking'],
+    limits: { scans: 100, projects: 3 }
+  },
+  pro: {
+    name: 'Professional',
+    features: ['verify', 'quality', 'hallucination', 'smells', 'breaking', 'mdc'],
+    limits: { scans: 1000, projects: 10 }
+  },
+  enterprise: {
+    name: 'Enterprise',
+    features: ['verify', 'quality', 'hallucination', 'smells', 'breaking', 'mdc'],
+    limits: { scans: -1, projects: -1 } // unlimited
+  }
+};
+
+/**
+ * Load user configuration from ~/.vibecheck/credentials.json
+ */
+async function loadUserConfig() {
+  try {
+    const configPath = path.join(os.homedir(), '.vibecheck', 'credentials.json');
+    const configData = await fs.readFile(configPath, 'utf-8');
+    return JSON.parse(configData);
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Determine tier from API key
+ */
+function getTierFromApiKey(apiKey) {
+  if (!apiKey) return 'free';
+  
+  if (apiKey.startsWith('gr_starter_')) return 'starter';
+  if (apiKey.startsWith('gr_pro_')) return 'pro';
+  if (apiKey.startsWith('gr_ent_')) return 'enterprise';
+  if (apiKey.startsWith('gr_free_')) return 'free';
+  
+  return 'free'; // default for unknown keys
+}
+
+/**
+ * Check if user has access to a specific feature
+ */
+export async function checkFeatureAccess(featureName, providedApiKey = null) {
+  // Try to load user config
+  const userConfig = await loadUserConfig();
+  const apiKey = providedApiKey || userConfig?.apiKey;
+  
+  if (!apiKey) {
+    return {
+      hasAccess: false,
+      tier: 'free',
+      reason: 'No API key provided. Run: vibecheck auth --key YOUR_API_KEY',
+      upgradeUrl: 'https://vibecheckai.dev/pricing'
+    };
+  }
+  
+  const tier = getTierFromApiKey(apiKey);
+  const tierConfig = TIERS[tier];
+  
+  if (!tierConfig.features.includes(featureName)) {
+    const requiredTier = Object.entries(TIERS).find(([_, config]) => 
+      config.features.includes(featureName)
+    )?.[0];
+    
+    return {
+      hasAccess: false,
+      tier,
+      reason: `${featureName} requires ${requiredTier} tier or higher`,
+      upgradeUrl: 'https://vibecheckai.dev/pricing'
+    };
+  }
+  
+  return {
+    hasAccess: true,
+    tier,
+    reason: 'Access granted'
+  };
+}
+
+/**
+ * Middleware for MCP tool handlers
+ */
+export function withTierCheck(featureName, handler) {
+  return async (args) => {
+    const access = await checkFeatureAccess(featureName, args?.apiKey);
+    
+    if (!access.hasAccess) {
+      return {
+        content: [{
+          type: "text",
+          text: `🚫 UPGRADE REQUIRED\n\n${access.reason}\n\nUpgrade at: ${access.upgradeUrl}`
+        }],
+        isError: true
+      };
+    }
+    
+    // Add tier info to args for the handler
+    args._tier = access.tier;
+    return handler(args);
+  };
+}
+
+/**
+ * Get current user info
+ */
+export async function getUserInfo() {
+  const config = await loadUserConfig();
+  if (!config) {
+    return {
+      authenticated: false,
+      tier: 'free',
+      message: 'Not authenticated. Run: vibecheck auth --key YOUR_API_KEY'
+    };
+  }
+  
+  const tier = getTierFromApiKey(config.apiKey);
+  return {
+    authenticated: true,
+    tier,
+    email: config.email,
+    authenticatedAt: config.authenticatedAt,
+    features: TIERS[tier].features,
+    limits: TIERS[tier].limits
+  };
+}

package/mcp-server/tools/index.js

@@ -0,0 +1,72 @@
+/**
+ * MCP Tools Index - Single Entry Point for All Tools
+ * 
+ * This module exports all MCP tools in a unified structure.
+ * Internal modules are organized by category but presented as one toolset.
+ * 
+ * Tool Categories:
+ * - Core: scan, ship, reality, fix, prove, report
+ * - Truth: ctx, guard, validate_claim, compile_context
+ * - AI: checkpoint, architect, intelligence
+ * 
+ * Usage:
+ *   import { ALL_TOOLS, handleTool } from './tools/index.js';
+ */
+
+// Re-export consolidated tools as the primary interface
+export { CONSOLIDATED_TOOLS, handleConsolidatedTool } from '../consolidated-tools.js';
+
+// Re-export truth firewall (hallucination stopper)
+export { TRUTH_FIREWALL_TOOLS, handleTruthFirewallTool } from '../truth-firewall-tools.js';
+
+// Re-export truth context
+export { TRUTH_CONTEXT_TOOLS, handleTruthContextTool } from '../truth-context.js';
+
+/**
+ * Get all recommended tools (consolidated + truth firewall)
+ */
+export function getRecommendedTools() {
+  const { CONSOLIDATED_TOOLS } = require('../consolidated-tools.js');
+  const { TRUTH_FIREWALL_TOOLS } = require('../truth-firewall-tools.js');
+  return [...CONSOLIDATED_TOOLS, ...TRUTH_FIREWALL_TOOLS];
+}
+
+/**
+ * Handle any tool call by routing to the appropriate handler
+ */
+export async function handleToolCall(toolName, args) {
+  // Route to consolidated handler first
+  const { handleConsolidatedTool, CONSOLIDATED_TOOLS } = await import('../consolidated-tools.js');
+  const consolidatedNames = CONSOLIDATED_TOOLS.map(t => t.name);
+  
+  if (consolidatedNames.includes(toolName)) {
+    return handleConsolidatedTool(toolName, args);
+  }
+  
+  // Route to truth firewall
+  const { handleTruthFirewallTool, TRUTH_FIREWALL_TOOLS } = await import('../truth-firewall-tools.js');
+  const firewallNames = TRUTH_FIREWALL_TOOLS.map(t => t.name);
+  
+  if (firewallNames.includes(toolName)) {
+    return handleTruthFirewallTool(toolName, args);
+  }
+  
+  // Route to truth context
+  const { handleTruthContextTool, TRUTH_CONTEXT_TOOLS } = await import('../truth-context.js');
+  const contextNames = TRUTH_CONTEXT_TOOLS.map(t => t.name);
+  
+  if (contextNames.includes(toolName)) {
+    return handleTruthContextTool(toolName, args);
+  }
+  
+  throw new Error(`Unknown tool: ${toolName}`);
+}
+
+/**
+ * Tool categories for documentation
+ */
+export const TOOL_CATEGORIES = {
+  core: ['vibecheck.scan', 'vibecheck.ship', 'vibecheck.reality', 'vibecheck.fix', 'vibecheck.prove', 'vibecheck.report'],
+  truth: ['vibecheck.ctx', 'vibecheck.get_truthpack', 'vibecheck.validate_claim', 'vibecheck.compile_context'],
+  guard: ['vibecheck.guard', 'vibecheck.check_route', 'vibecheck.check_env', 'vibecheck.check_auth'],
+};

package/mcp-server/tools-reorganized.ts

@@ -0,0 +1,244 @@
+/**
+ * MCP Tools Reorganized into 5 Groups
+ * 
+ * Truth, Impact, Standards, Security, Workflow
+ * ~20 tools total, grouped for sanity
+ */
+
+export const TRUTH_TOOLS = [
+  {
+    name: 'repo_map',
+    description: 'Get complete repository map (structure, files, relationships)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+  {
+    name: 'symbols_exists',
+    description: 'Check if symbol exists in codebase',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        symbol: { type: 'string', description: 'Symbol name to check' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+  {
+    name: 'symbols_find',
+    description: 'Find symbol definition location',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        symbol: { type: 'string', description: 'Symbol name' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+  {
+    name: 'symbols_fuzzy',
+    description: 'Fuzzy search for symbols',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+  {
+    name: 'versions_allowed',
+    description: 'Check if dependency version is allowed',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        package: { type: 'string', description: 'Package name' },
+        version: { type: 'string', description: 'Version to check' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+];
+
+export const IMPACT_TOOLS = [
+  {
+    name: 'graph_related',
+    description: 'Get blast radius - files affected by changes',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'File path' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+];
+
+export const STANDARDS_TOOLS = [
+  {
+    name: 'patterns_pick',
+    description: 'Pick appropriate pattern from codebase',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        patternType: { type: 'string', description: 'Type of pattern needed' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+  {
+    name: 'architecture_check',
+    description: 'Check code against architecture patterns',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'Code to check' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+  {
+    name: 'boundary_check',
+    description: 'Check if code respects architectural boundaries',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'File path' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+];
+
+export const SECURITY_TOOLS = [
+  {
+    name: 'antipatterns_scan',
+    description: 'Scan for code smells and security footguns',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'File path' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+  {
+    name: 'antipatterns_check',
+    description: 'Check specific code against antipatterns',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'Code to check' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+  {
+    name: 'vulnerabilities_scan',
+    description: 'Scan dependencies for vulnerabilities',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+  {
+    name: 'vulnerability_check',
+    description: 'Check specific package/version for vulnerabilities',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        package: { type: 'string', description: 'Package name' },
+        version: { type: 'string', description: 'Version' },
+      },
+    },
+  },
+];
+
+export const WORKFLOW_TOOLS = [
+  {
+    name: 'scope_declare',
+    description: 'Declare intent/scope before writing code',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        intent: { type: 'string', description: 'What you intend to do' },
+        scope: { type: 'string', description: 'Scope of changes' },
+      },
+    },
+  },
+  {
+    name: 'scope_check',
+    description: 'Check if code changes align with declared scope',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'Code to check' },
+        declaredScope: { type: 'string', description: 'Originally declared scope' },
+      },
+    },
+  },
+  {
+    name: 'autopilot',
+    description: 'Intent classification and autopilot suggestions',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        intent: { type: 'string', description: 'User intent' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+  {
+    name: 'verify_fast',
+    description: 'Fast pre-write verification',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'Code to verify' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+  {
+    name: 'verify_deep',
+    description: 'Deep verification with runtime checks',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'Code to verify' },
+        projectPath: { type: 'string', description: 'Project path' },
+      },
+    },
+  },
+];
+
+/**
+ * All tools grouped
+ */
+export const ALL_MCP_TOOLS = [
+  ...TRUTH_TOOLS,
+  ...IMPACT_TOOLS,
+  ...STANDARDS_TOOLS,
+  ...SECURITY_TOOLS,
+  ...WORKFLOW_TOOLS,
+];
+
+/**
+ * Tool response format (world-class rules)
+ */
+export interface ToolResponse {
+  verdict: 'PASS' | 'FAIL' | 'WARN' | 'INDEX_REQUIRED';
+  proof: any; // Evidence/proof data
+  nextAction: string; // What to do next
+  latency?: number; // Tool execution time in ms
+  blockedHallucination?: boolean; // Did this prevent a hallucination?
+  prevented?: {
+    type: 'symbol' | 'route' | 'version' | 'boundary';
+    value: string;
+  };
+}