@vibecheckai/cli 3.9.1 → 4.0.0

package/mcp-server/registry.test.ts

@@ -1,340 +0,0 @@
-/**
- * Registry Tests
- * 
- * Ensures every tool in the registry has:
- * - Valid input/output schemas
- * - CLI mapping with command
- * - Proper tier assignment
- * - Required metadata
- */
-
-import { describe, it, expect, beforeAll } from "vitest";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import Ajv from "ajv";
-
-import {
-  getAllTools,
-  getToolByName,
-  listToolNames,
-  getToolsByTier,
-  getToolsByCategory,
-  validateRegistry,
-} from "./handlers/tool-handler.js";
-import type { ToolDefinition } from "./lib/types.js";
-
-// ESM __dirname equivalent
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// TEST SETUP
-// ═══════════════════════════════════════════════════════════════════════════════
-
-const AjvClass = Ajv.default || Ajv;
-const ajv = new AjvClass({ allErrors: true, strict: false });
-
-// Load registry directly for raw tests
-const registryPath = path.join(__dirname, "registry/tools.json");
-let rawRegistry: { tools: Record<string, ToolDefinition> };
-
-beforeAll(() => {
-  const content = fs.readFileSync(registryPath, "utf-8");
-  rawRegistry = JSON.parse(content);
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// REGISTRY STRUCTURE TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("Registry Structure", () => {
-  it("should load registry file", () => {
-    expect(rawRegistry).toBeDefined();
-    expect(rawRegistry.tools).toBeDefined();
-    expect(Object.keys(rawRegistry.tools).length).toBeGreaterThan(0);
-  });
-
-  it("should have valid JSON schema structure", () => {
-    // Registry itself should be valid JSON
-    expect(() => JSON.stringify(rawRegistry)).not.toThrow();
-  });
-
-  it("should pass validateRegistry check", () => {
-    const result = validateRegistry();
-    expect(result.errors).toEqual([]);
-    expect(result.valid).toBe(true);
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// TOOL DEFINITION TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("Tool Definitions", () => {
-  const tools = getAllTools();
-
-  it("should have at least one tool", () => {
-    expect(tools.length).toBeGreaterThan(0);
-  });
-
-  describe.each(tools.map((t) => [t.name, t] as const))("%s", (name: string, tool: ToolDefinition) => {
-    // Required Fields
-    it("should have name matching key", () => {
-      expect(tool.name).toBe(name);
-    });
-
-    it("should have description", () => {
-      expect(tool.description).toBeDefined();
-      expect(tool.description.length).toBeGreaterThan(10);
-    });
-
-    it("should have valid tier", () => {
-      expect(["free", "pro"]).toContain(tool.tier);
-    });
-
-    it("should have valid category", () => {
-      const validCategories = ["scan", "proof", "authority", "report", "setup", "account", "conductor", "firewall"];
-      expect(validCategories).toContain(tool.category);
-    });
-
-    // Schema Tests
-    describe("Input Schema", () => {
-      it("should have inputSchema", () => {
-        expect(tool.inputSchema).toBeDefined();
-        expect(tool.inputSchema.type).toBe("object");
-      });
-
-      it("should have valid inputSchema (compiles)", () => {
-        expect(() => ajv.compile(tool.inputSchema)).not.toThrow();
-      });
-
-      it("should have properties defined", () => {
-        expect(tool.inputSchema.properties).toBeDefined();
-      });
-
-      it("should have additionalProperties set to false", () => {
-        expect(tool.inputSchema.additionalProperties).toBe(false);
-      });
-    });
-
-    describe("Output Schema", () => {
-      it("should have outputSchema", () => {
-        expect(tool.outputSchema).toBeDefined();
-        expect(tool.outputSchema.type).toBe("object");
-      });
-
-      it("should have valid outputSchema (compiles)", () => {
-        expect(() => ajv.compile(tool.outputSchema)).not.toThrow();
-      });
-    });
-
-    // CLI Mapping Tests
-    describe("CLI Mapping", () => {
-      it("should have cli mapping", () => {
-        expect(tool.cli).toBeDefined();
-      });
-
-      it("should have cli.command", () => {
-        expect(tool.cli.command).toBeDefined();
-        expect(tool.cli.command.length).toBeGreaterThan(0);
-      });
-
-      it("should have cli.argMap", () => {
-        expect(tool.cli.argMap).toBeDefined();
-        expect(typeof tool.cli.argMap).toBe("object");
-      });
-
-      it("should map all input properties to CLI flags", () => {
-        const inputProps = Object.keys(tool.inputSchema.properties || {});
-        const mappedProps = Object.keys(tool.cli.argMap);
-        
-        // Every input property should have a mapping (can be empty string for positional)
-        for (const prop of inputProps) {
-          // projectPath is commonly mapped, but we allow unmapped internal props
-          if (!["projectPath"].includes(prop)) {
-            expect(mappedProps).toContain(prop);
-          }
-        }
-      });
-
-      it("should have --json in fixedFlags", () => {
-        expect(tool.cli.fixedFlags).toContain("--json");
-      });
-
-      it("should have reasonable timeout", () => {
-        expect(tool.cli.timeoutMs).toBeGreaterThan(0);
-        expect(tool.cli.timeoutMs).toBeLessThanOrEqual(900000); // Max 15 minutes
-      });
-    });
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// TIER DISTRIBUTION TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("Tier Distribution", () => {
-  it("should have free tools", () => {
-    const freeTools = getToolsByTier("free");
-    expect(freeTools.length).toBeGreaterThan(0);
-  });
-
-  it("should have pro tools", () => {
-    const proTools = getToolsByTier("pro");
-    expect(proTools.length).toBeGreaterThan(0);
-  });
-
-  it("free tools should include scan, report, doctor, classify", () => {
-    const freeTools = getToolsByTier("free").map((t: ToolDefinition) => t.name);
-    expect(freeTools).toContain("vibecheck.scan");
-    expect(freeTools).toContain("vibecheck.report");
-    expect(freeTools).toContain("vibecheck.doctor");
-    expect(freeTools).toContain("vibecheck.classify");
-  });
-
-  it("pro tools should include ship, fix, prove, reality", () => {
-    const proTools = getToolsByTier("pro").map((t: ToolDefinition) => t.name);
-    expect(proTools).toContain("vibecheck.ship");
-    expect(proTools).toContain("vibecheck.fix");
-    expect(proTools).toContain("vibecheck.prove");
-    expect(proTools).toContain("vibecheck.reality");
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// CATEGORY TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("Categories", () => {
-  it("should have tools in scan category", () => {
-    const scanTools = getToolsByCategory("scan");
-    expect(scanTools.length).toBeGreaterThan(0);
-  });
-
-  it("should have tools in proof category", () => {
-    const proofTools = getToolsByCategory("proof");
-    expect(proofTools.length).toBeGreaterThan(0);
-  });
-
-  it("should have tools in setup category", () => {
-    const setupTools = getToolsByCategory("setup");
-    expect(setupTools.length).toBeGreaterThan(0);
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// ALIAS TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("Aliases", () => {
-  it("should resolve tool by alias", () => {
-    // vibecheck.scan has alias "scan"
-    const tool = getToolByName("scan");
-    expect(tool).not.toBeNull();
-    expect(tool?.name).toBe("vibecheck.scan");
-  });
-
-  it("should resolve tool by another alias", () => {
-    // vibecheck.ship has alias "verdict"
-    const tool = getToolByName("verdict");
-    expect(tool).not.toBeNull();
-    expect(tool?.name).toBe("vibecheck.ship");
-  });
-
-  it("should return null for unknown tool", () => {
-    const tool = getToolByName("nonexistent-tool");
-    expect(tool).toBeNull();
-  });
-
-  it("aliases should be unique across all tools", () => {
-    const allAliases: string[] = [];
-    const tools = getAllTools();
-
-    for (const tool of tools) {
-      if (tool.aliases) {
-        for (const alias of tool.aliases) {
-          expect(allAliases).not.toContain(alias);
-          allAliases.push(alias);
-        }
-      }
-    }
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// CLI COMMAND MAPPING TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("CLI Command Mapping", () => {
-  const VALID_CLI_COMMANDS = new Set([
-    // From bin/registry.js
-    "init", "doctor", "watch", "scan", "report", "context", "classify",
-    "login", "logout", "whoami", "allowlist", "evidence-pack", "labs",
-    "ship", "fix", "prove", "reality", "gate", "guard", "mcp",
-    "checkpoint", "approve", "polish",
-  ]);
-
-  it("all tools should map to valid CLI commands", () => {
-    const tools = getAllTools();
-    
-    for (const tool of tools) {
-      expect(VALID_CLI_COMMANDS.has(tool.cli.command)).toBe(true);
-    }
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// SCHEMA COMPLETENESS TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("Schema Completeness", () => {
-  it("all input properties should have descriptions", () => {
-    const tools = getAllTools();
-    
-    for (const tool of tools) {
-      const props = tool.inputSchema.properties || {};
-      for (const [_propName, propSchema] of Object.entries(props)) {
-        expect((propSchema as { description?: string }).description).toBeDefined();
-      }
-    }
-  });
-
-  it("all input properties should have types", () => {
-    const tools = getAllTools();
-    
-    for (const tool of tools) {
-      const props = tool.inputSchema.properties || {};
-      for (const [_propName, propSchema] of Object.entries(props)) {
-        expect((propSchema as { type?: string }).type).toBeDefined();
-      }
-    }
-  });
-
-  it("scan-related tools should output findings array", () => {
-    const scanTools = ["vibecheck.scan", "vibecheck.ship"];
-    
-    for (const toolName of scanTools) {
-      const tool = getToolByName(toolName);
-      expect(tool).not.toBeNull();
-      expect(tool?.outputSchema.properties?.findings).toBeDefined();
-    }
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// LISTING TESTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("Tool Listing", () => {
-  it("listToolNames should return all tool names", () => {
-    const names = listToolNames();
-    const tools = getAllTools();
-    
-    expect(names.length).toBe(tools.length);
-    
-    for (const tool of tools) {
-      expect(names).toContain(tool.name);
-    }
-  });
-});

package/mcp-server/test-mcp.js

@@ -1,108 +0,0 @@
-#!/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

@@ -1,36 +0,0 @@
-#!/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);
-}